voxflow 1.15.0 → 1.15.2

package/lib/internal/deck-validator.js

@@ -0,0 +1,488 @@
+'use strict';
+
+/**
+ * PaperSlideDeck shape validator — vendored copy for the CLI's offline route.
+ *
+ * Source of truth lives at backend/services/paper-slide/deck-validator.js;
+ * this file is a verbatim copy except for the slice-themes.json require path.
+ * The copy keeps the published `voxflow` tarball self-contained — users who
+ * `npm install voxflow` get the validator without needing the monorepo.
+ *
+ * To re-sync after upstream changes:
+ *   cp backend/services/paper-slide/deck-validator.js  cli/lib/internal/deck-validator.js
+ *   cp slice-themes.json                                cli/lib/internal/slice-themes.json
+ *   # then re-apply the require-path tweak below.
+ */
+
+const SLICE_THEME_REGISTRY = require('./slice-themes.json');
+const VALID_THEMES = new Set(SLICE_THEME_REGISTRY.themes.map((t) => t.id));
+
+// Theme id -> Set of valid variant ids, derived from the canonical registry.
+// Themes without a `variants[]` entry get an empty set; the validator then
+// rejects any non-null variantId so an unexpected value can't slip through.
+const THEME_VARIANTS = new Map(
+    SLICE_THEME_REGISTRY.themes.map((t) => [
+        t.id,
+        new Set((t.variants || []).map((v) => v.id)),
+    ])
+);
+
+// Rich card kinds (P6). title/body/outro are the original three. quote/data/list
+// are content-shape variants the LLM may emit when the article has a quotable
+// line / a stand-out number / a 3-point structure. The render-worker pipeline
+// downgrades the new kinds to body shape per-theme (paper-slide + editorial-mag
+// get real visual treatments in a follow-up; other 4 themes always fall back).
+const VALID_KINDS = new Set(['title', 'body', 'quote', 'data', 'list', 'outro']);
+
+// Caps mirrored from the prompt — kept here so the validator rejects an LLM
+// over-shoot rather than letting an unrenderable card slip through to the
+// renderer's text-box.
+const QUOTE_TEXT_MAX = 60;
+const QUOTE_ATTRIBUTION_MAX = 30;
+const DATA_VALUE_MAX = 12;
+const DATA_UNIT_MAX = 8;
+const DATA_LABEL_MAX = 30;
+const LIST_ITEM_MAX_LEN = 30;
+const LIST_ITEM_MIN_COUNT = 2;
+const LIST_ITEM_MAX_COUNT = 4;
+
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+
+function validateQuotePayload(quote, i) {
+    if (!quote || typeof quote !== 'object') {
+        throw new Error(`cards[${i}].quote must be an object`);
+    }
+    if (!nonEmptyString(quote.text)) {
+        throw new Error(`cards[${i}].quote.text empty`);
+    }
+    if (quote.text.length > QUOTE_TEXT_MAX) {
+        throw new Error(`cards[${i}].quote.text too long (${quote.text.length} > ${QUOTE_TEXT_MAX})`);
+    }
+    if (quote.attribution != null) {
+        if (typeof quote.attribution !== 'string') {
+            throw new Error(`cards[${i}].quote.attribution must be string or null`);
+        }
+        if (quote.attribution.length > QUOTE_ATTRIBUTION_MAX) {
+            throw new Error(
+                `cards[${i}].quote.attribution too long (${quote.attribution.length} > ${QUOTE_ATTRIBUTION_MAX})`
+            );
+        }
+    }
+}
+
+function validateDataPayload(data, i) {
+    if (!data || typeof data !== 'object') {
+        throw new Error(`cards[${i}].data must be an object`);
+    }
+    if (!nonEmptyString(data.value)) {
+        throw new Error(`cards[${i}].data.value empty`);
+    }
+    if (data.value.length > DATA_VALUE_MAX) {
+        throw new Error(`cards[${i}].data.value too long (${data.value.length} > ${DATA_VALUE_MAX})`);
+    }
+    if (!nonEmptyString(data.label)) {
+        throw new Error(`cards[${i}].data.label empty`);
+    }
+    if (data.label.length > DATA_LABEL_MAX) {
+        throw new Error(`cards[${i}].data.label too long (${data.label.length} > ${DATA_LABEL_MAX})`);
+    }
+    if (data.unit != null) {
+        if (typeof data.unit !== 'string') {
+            throw new Error(`cards[${i}].data.unit must be string or null`);
+        }
+        if (data.unit.length > DATA_UNIT_MAX) {
+            throw new Error(`cards[${i}].data.unit too long (${data.unit.length} > ${DATA_UNIT_MAX})`);
+        }
+    }
+}
+
+function validateListPayload(list, i) {
+    if (!list || typeof list !== 'object') {
+        throw new Error(`cards[${i}].list must be an object`);
+    }
+    if (!Array.isArray(list.items)) {
+        throw new Error(`cards[${i}].list.items must be array`);
+    }
+    if (list.items.length < LIST_ITEM_MIN_COUNT || list.items.length > LIST_ITEM_MAX_COUNT) {
+        throw new Error(
+            `cards[${i}].list.items must be ${LIST_ITEM_MIN_COUNT}–${LIST_ITEM_MAX_COUNT} entries (got ${list.items.length})`
+        );
+    }
+    list.items.forEach((item, j) => {
+        if (!item || typeof item !== 'object') {
+            throw new Error(`cards[${i}].list.items[${j}] must be object`);
+        }
+        if (!nonEmptyString(item.text)) {
+            throw new Error(`cards[${i}].list.items[${j}].text empty`);
+        }
+        if (item.text.length > LIST_ITEM_MAX_LEN) {
+            throw new Error(
+                `cards[${i}].list.items[${j}].text too long (${item.text.length} > ${LIST_ITEM_MAX_LEN})`
+            );
+        }
+        if (item.glyph != null && typeof item.glyph !== 'string') {
+            throw new Error(`cards[${i}].list.items[${j}].glyph must be string or null`);
+        }
+    });
+}
+
+function validatePaperSlideDeck(deck) {
+    if (!deck || typeof deck !== 'object') throw new Error('deck missing');
+    for (const f of ['header', 'seriesTitle', 'seriesTagline']) {
+        if (typeof deck[f] !== 'string' || !deck[f].trim()) {
+            throw new Error(`deck.${f} missing or empty`);
+        }
+    }
+    // Optional cover hints — ignored if absent (null/undefined OK);
+    // hard fail only if present and wrong type (non-string).
+    // Cover always has a deterministic fallback from card data.
+    for (const f of ['coverHookCaption', 'coverFigureKeyword']) {
+        if (deck[f] != null && typeof deck[f] !== 'string') {
+            throw new Error(`deck.${f} must be string or null`);
+        }
+    }
+    // Optional theme — defaults to 'paper-slide' downstream when absent.
+    // Reject unknown values explicitly so a typo'd theme never silently
+    // routes to the default composition (would mask real bugs).
+    if (deck.theme != null && !VALID_THEMES.has(deck.theme)) {
+        throw new Error(
+            `deck.theme invalid: ${deck.theme} (valid: ${[...VALID_THEMES].join(', ')})`
+        );
+    }
+    // Optional variantId — palette swap within the current theme (e.g.
+    // editorial-mag has cream/sepia/cold-grey). Validated against the
+    // registry's `variants[]` for the selected (or default) theme. Themes
+    // that don't declare variants reject any non-null variantId — a typo'd
+    // variant should never silently fall back to the default palette.
+    if (deck.variantId != null) {
+        if (typeof deck.variantId !== 'string' || !deck.variantId.trim()) {
+            throw new Error('deck.variantId must be a non-empty string when present');
+        }
+        const themeId = deck.theme || SLICE_THEME_REGISTRY.default;
+        const validVariants = THEME_VARIANTS.get(themeId) || new Set();
+        if (validVariants.size === 0) {
+            throw new Error(
+                `deck.variantId set but theme "${themeId}" declares no variants`
+            );
+        }
+        if (!validVariants.has(deck.variantId)) {
+            throw new Error(
+                `deck.variantId invalid for theme "${themeId}": ${deck.variantId} (valid: ${[...validVariants].join(', ')})`
+            );
+        }
+    }
+    // Optional aiCoverUrl — public Supabase Storage URL of an AI-generated
+    // cover the user kept across edits. Persisted in cards_data.deck so a
+    // second-pass render of the same project doesn't lose the candidate
+    // (Phase 7 — AiCoverPanel wiring lands the read path). Validated as a
+    // public-assets URL only; rejecting other origins keeps the field from
+    // becoming an arbitrary-URL injection vector via the deck shape.
+    if (deck.aiCoverUrl != null) {
+        if (typeof deck.aiCoverUrl !== 'string' || !deck.aiCoverUrl.trim()) {
+            throw new Error('deck.aiCoverUrl must be a non-empty string when present');
+        }
+        const allowedPrefix =
+            'https://iwkonytsjysszmafqchh.supabase.co/storage/v1/object/public/public-assets/';
+        if (!deck.aiCoverUrl.startsWith(allowedPrefix)) {
+            throw new Error('deck.aiCoverUrl must be a public-assets bucket URL');
+        }
+    }
+    // Card-count cap widened from 8 → 9 because BrandKit auto-appends an
+    // outro card on top of the LLM's max-6-card output (5 narrative + 1
+    // title still fits well below 9). Outro is appended server-side after
+    // slicing, so the LLM still targets 4–6 narrative cards.
+    if (!Array.isArray(deck.cards) || deck.cards.length < 2 || deck.cards.length > 9) {
+        throw new Error(`deck.cards must be 2–9 entries (got ${deck.cards?.length})`);
+    }
+    if (deck.cards[0].kind !== 'title') {
+        throw new Error('first card must be kind=title');
+    }
+    // Outro card invariant: at most one, and only as the LAST card. Multiple
+    // outros or a mid-deck outro is always a wiring bug worth surfacing
+    // (e.g. double-injection on retry) — fail loud rather than render twice.
+    const outroCount = deck.cards.filter((c) => c.kind === 'outro').length;
+    if (outroCount > 1) throw new Error(`deck has ${outroCount} outro cards (max 1)`);
+    if (outroCount === 1 && deck.cards[deck.cards.length - 1].kind !== 'outro') {
+        throw new Error('outro card must be last');
+    }
+    deck.cards.forEach((card, i) => {
+        if (!VALID_KINDS.has(card.kind)) {
+            throw new Error(`cards[${i}].kind invalid: ${card.kind}`);
+        }
+        if (typeof card.narration !== 'string' || !card.narration.trim()) {
+            throw new Error(`cards[${i}].narration empty`);
+        }
+        if (card.kind === 'title' && (!Array.isArray(card.title) || card.title.length === 0)) {
+            throw new Error(`cards[${i}].title must be non-empty array for kind=title`);
+        }
+        if (card.kind === 'body' && (!card.caption || !String(card.caption).trim())) {
+            throw new Error(`cards[${i}].caption empty for kind=body`);
+        }
+        if (card.kind === 'quote') validateQuotePayload(card.quote, i);
+        if (card.kind === 'data') validateDataPayload(card.data, i);
+        if (card.kind === 'list') validateListPayload(card.list, i);
+        // Optional per-card voice override (#3220). Absent ⇒ render-worker
+        // uses the job-level voiceId. Shape check only — the voice library is
+        // the source of truth for valid IDs, and the TTS request will surface
+        // a clean 404 if the voiceId is unknown / not owned by the user.
+        if (card.voiceId != null) {
+            if (typeof card.voiceId !== 'string' || !card.voiceId.trim()) {
+                throw new Error(`cards[${i}].voiceId must be a non-empty string when present`);
+            }
+            if (card.voiceId.length > 128) {
+                throw new Error(`cards[${i}].voiceId too long (${card.voiceId.length} > 128)`);
+            }
+        }
+        // Optional per-card image URL — photo-feature / atmospheric themes
+        // composite it as a full-bleed background; other themes ignore it.
+        // Shape-check only (string, length cap, http(s) prefix); reachability
+        // is handled at render time by the composition's onError fallback.
+        if (card.imageUrl != null) {
+            if (typeof card.imageUrl !== 'string') {
+                throw new Error(`cards[${i}].imageUrl must be string or null`);
+            }
+            if (card.imageUrl.length > 2048) {
+                throw new Error(
+                    `cards[${i}].imageUrl too long (${card.imageUrl.length} > 2048)`
+                );
+            }
+            if (!/^https?:\/\//.test(card.imageUrl)) {
+                throw new Error(`cards[${i}].imageUrl must start with http(s)://`);
+            }
+        }
+        if (card.kind === 'outro') {
+            if (!card.outro || typeof card.outro !== 'object') {
+                throw new Error(`cards[${i}].outro must be an object`);
+            }
+            if (typeof card.outro.cta !== 'string' || !card.outro.cta.trim()) {
+                throw new Error(`cards[${i}].outro.cta empty`);
+            }
+            if (card.outro.handle != null && typeof card.outro.handle !== 'string') {
+                throw new Error(`cards[${i}].outro.handle must be string or null`);
+            }
+        }
+    });
+    // Optional brandKit snapshot — pure shape check, identity is server-
+    // populated so we can be strict about types (catches client-side
+    // tampering / version skew).
+    if (deck.brandKit != null) {
+        if (typeof deck.brandKit !== 'object') throw new Error('deck.brandKit must be object');
+        const bk = deck.brandKit;
+        for (const f of ['displayName', 'orgName', 'handle', 'brandColor']) {
+            if (bk[f] != null && typeof bk[f] !== 'string') {
+                throw new Error(`deck.brandKit.${f} must be string or null`);
+            }
+        }
+        if (bk.footerPosition != null && !['bottom-left', 'bottom-right', 'none'].includes(bk.footerPosition)) {
+            throw new Error('deck.brandKit.footerPosition invalid');
+        }
+    }
+}
+
+// ── V2 LayoutTree-shaped deck validation (#3434) ─────────────────────────────
+//
+// Slice v2 cards are LayoutTrees instead of kind-tagged fields. v1 ships
+// for theme=paper-slide only; other themes keep V1. The element set is
+// deliberately restricted vs ai-clips' 17-element schema — paper-slide's
+// renderer only knows how to style these 6 (heading / body / paper-figure
+// / quote / stat / steps). Anything else is rejected so a renderer that
+// silently no-ops on unknown elements doesn't ship a broken video.
+
+const V2_ALLOWED_ELEMENTS = new Set(['heading', 'body', 'paper-figure', 'quote', 'stat', 'steps']);
+const V2_HEADING_MAX = 22;
+const V2_BODY_TEXT_MAX = 30;
+const V2_STAT_LABEL_MAX = 30;
+
+function validateV2Children(children, cardIdx, allowedElements, opts = {}) {
+    if (!Array.isArray(children) || children.length === 0) {
+        throw new Error(`cards[${cardIdx}].children must be non-empty array`);
+    }
+    if (opts.maxChildren && children.length > opts.maxChildren) {
+        throw new Error(`cards[${cardIdx}].children too many (${children.length} > ${opts.maxChildren})`);
+    }
+    const elements = [];
+    children.forEach((el, j) => {
+        if (!el || typeof el !== 'object') {
+            throw new Error(`cards[${cardIdx}].children[${j}] must be object`);
+        }
+        if (!allowedElements.has(el.el)) {
+            throw new Error(
+                `cards[${cardIdx}].children[${j}].el invalid: ${el.el} ` +
+                `(allowed for this kind: ${[...allowedElements].join(', ')})`
+            );
+        }
+        elements.push(el);
+        if (el.el === 'heading') {
+            if (!nonEmptyString(el.text)) throw new Error(`cards[${cardIdx}].children[${j}].text empty`);
+            if (el.text.length > V2_HEADING_MAX) {
+                throw new Error(`cards[${cardIdx}].children[${j}].text too long (${el.text.length} > ${V2_HEADING_MAX})`);
+            }
+            // Trailing punctuation guard — prompt rule, mirrored in validator
+            // so LLM drift can't slip a trailing 。！？ through to subtitles.
+            if (/[。！？.!?…]$/.test(el.text.trim())) {
+                throw new Error(`cards[${cardIdx}].children[${j}].text must not end with punctuation`);
+            }
+        } else if (el.el === 'body') {
+            if (!nonEmptyString(el.text)) throw new Error(`cards[${cardIdx}].children[${j}].text empty`);
+            if (el.text.length > V2_BODY_TEXT_MAX) {
+                throw new Error(`cards[${cardIdx}].children[${j}].text too long (${el.text.length} > ${V2_BODY_TEXT_MAX})`);
+            }
+        } else if (el.el === 'paper-figure') {
+            if (!nonEmptyString(el.figureKeyword)) {
+                throw new Error(`cards[${cardIdx}].children[${j}].figureKeyword empty`);
+            }
+        } else if (el.el === 'quote') {
+            validateQuotePayload({ text: el.text, attribution: el.attribution }, cardIdx);
+        } else if (el.el === 'stat') {
+            // stat.value may be number or numeric string ("3x" / "240万+")
+            if (el.value == null || (typeof el.value !== 'number' && !nonEmptyString(el.value))) {
+                throw new Error(`cards[${cardIdx}].children[${j}].value missing`);
+            }
+            const valueStr = String(el.value);
+            if (valueStr.length > DATA_VALUE_MAX) {
+                throw new Error(`cards[${cardIdx}].children[${j}].value too long (${valueStr.length} > ${DATA_VALUE_MAX})`);
+            }
+            if (el.unit != null) {
+                if (typeof el.unit !== 'string') throw new Error(`cards[${cardIdx}].children[${j}].unit must be string`);
+                if (el.unit.length > DATA_UNIT_MAX) {
+                    throw new Error(`cards[${cardIdx}].children[${j}].unit too long (${el.unit.length} > ${DATA_UNIT_MAX})`);
+                }
+            }
+            if (el.label != null) {
+                if (typeof el.label !== 'string') throw new Error(`cards[${cardIdx}].children[${j}].label must be string`);
+                if (el.label.length > V2_STAT_LABEL_MAX) {
+                    throw new Error(`cards[${cardIdx}].children[${j}].label too long (${el.label.length} > ${V2_STAT_LABEL_MAX})`);
+                }
+            }
+        } else if (el.el === 'steps') {
+            if (!Array.isArray(el.items) || el.items.length < LIST_ITEM_MIN_COUNT || el.items.length > LIST_ITEM_MAX_COUNT) {
+                throw new Error(
+                    `cards[${cardIdx}].children[${j}].items must be ${LIST_ITEM_MIN_COUNT}–${LIST_ITEM_MAX_COUNT} entries`
+                );
+            }
+            el.items.forEach((item, k) => {
+                if (!item || typeof item !== 'object') {
+                    throw new Error(`cards[${cardIdx}].children[${j}].items[${k}] must be object`);
+                }
+                if (!nonEmptyString(item.label)) {
+                    throw new Error(`cards[${cardIdx}].children[${j}].items[${k}].label empty`);
+                }
+                if (item.label.length > LIST_ITEM_MAX_LEN) {
+                    throw new Error(
+                        `cards[${cardIdx}].children[${j}].items[${k}].label too long (${item.label.length} > ${LIST_ITEM_MAX_LEN})`
+                    );
+                }
+            });
+        }
+    });
+    return elements;
+}
+
+function validatePaperSlideDeckV2(deck) {
+    if (!deck || typeof deck !== 'object') throw new Error('deck missing');
+    for (const f of ['header', 'seriesTitle', 'seriesTagline']) {
+        if (!nonEmptyString(deck[f])) {
+            throw new Error(`deck.${f} missing or empty`);
+        }
+    }
+    for (const f of ['coverHookCaption', 'coverFigureKeyword']) {
+        if (deck[f] != null && typeof deck[f] !== 'string') {
+            throw new Error(`deck.${f} must be string or null`);
+        }
+    }
+    if (deck.theme != null && !VALID_THEMES.has(deck.theme)) {
+        throw new Error(`deck.theme invalid: ${deck.theme}`);
+    }
+    // V2 only ships for paper-slide in v1. Reject other themes loudly so a
+    // wrong-theme deck never hits the V2 renderer (which doesn't know how to
+    // style for editorial-mag / bold-poster / etc.).
+    if (deck.theme != null && deck.theme !== 'paper-slide') {
+        throw new Error(`v2 LayoutTree decks only supported for paper-slide theme (got ${deck.theme})`);
+    }
+    if (!Array.isArray(deck.cards) || deck.cards.length < 3 || deck.cards.length > 6) {
+        throw new Error(`deck.cards must be 3–6 entries (got ${deck.cards?.length})`);
+    }
+    if (deck.cards[0].kind !== 'title') {
+        throw new Error('first card must be kind=title');
+    }
+    // Cap on rich-kind cards to keep variety up
+    const richCounts = { quote: 0, data: 0, list: 0 };
+    deck.cards.forEach((card, i) => {
+        if (!card || typeof card !== 'object') throw new Error(`cards[${i}] missing`);
+        if (!['title', 'body', 'quote', 'data', 'list'].includes(card.kind)) {
+            throw new Error(`cards[${i}].kind invalid: ${card.kind} (v2 supports title/body/quote/data/list)`);
+        }
+        if (!nonEmptyString(card.narration)) throw new Error(`cards[${i}].narration empty`);
+
+        if (card.kind === 'title') {
+            const els = validateV2Children(card.children, i, new Set(['heading']), { maxChildren: 3 });
+            if (els.length === 0) throw new Error(`cards[${i}] title must have at least one heading`);
+        } else if (card.kind === 'body') {
+            const els = validateV2Children(card.children, i, new Set(['heading', 'body', 'paper-figure']), { maxChildren: 4 });
+            const figs = els.filter((e) => e.el === 'paper-figure');
+            if (figs.length !== 1) throw new Error(`cards[${i}] body must contain exactly one paper-figure (got ${figs.length})`);
+            const heads = els.filter((e) => e.el === 'heading');
+            if (heads.length === 0) throw new Error(`cards[${i}] body must contain at least one heading`);
+        } else if (card.kind === 'quote') {
+            // LLM frequently prepends a heading and/or body descriptor to rich
+            // cards — allow them (the PaperSlide renderer reads quote.text /
+            // stat / steps directly and ignores any non-discriminator elements
+            // on these kinds). Discriminator element must still be present
+            // exactly once. Cap at 3 children to keep output bounded.
+            const els = validateV2Children(card.children, i, new Set(['heading', 'body', 'quote']), { maxChildren: 3 });
+            const quoteEls = els.filter((e) => e.el === 'quote');
+            if (quoteEls.length !== 1) throw new Error(`cards[${i}] quote card must contain exactly one quote element (got ${quoteEls.length})`);
+            richCounts.quote += 1;
+        } else if (card.kind === 'data') {
+            const els = validateV2Children(card.children, i, new Set(['heading', 'body', 'stat']), { maxChildren: 3 });
+            const statEls = els.filter((e) => e.el === 'stat');
+            if (statEls.length !== 1) throw new Error(`cards[${i}] data card must contain exactly one stat element (got ${statEls.length})`);
+            richCounts.data += 1;
+        } else if (card.kind === 'list') {
+            const els = validateV2Children(card.children, i, new Set(['heading', 'body', 'steps']), { maxChildren: 3 });
+            const stepsEls = els.filter((e) => e.el === 'steps');
+            if (stepsEls.length !== 1) throw new Error(`cards[${i}] list card must contain exactly one steps element (got ${stepsEls.length})`);
+            richCounts.list += 1;
+        }
+    });
+    // Cap on rich-kind variety — at most 1 of each (same as V1 prompt rule)
+    for (const k of Object.keys(richCounts)) {
+        if (richCounts[k] > 1) {
+            throw new Error(`deck has ${richCounts[k]} ${k} cards (max 1 per deck)`);
+        }
+    }
+}
+
+/**
+ * Detect whether a deck is V2 LayoutTree-shaped. The discriminator is the
+ * presence of `children` on the first card — V1 cards never have it. Falls
+ * back to V1 detection so callers can use this as a switch point.
+ */
+function isV2LayoutTreeDeck(deck) {
+    return !!(deck && Array.isArray(deck.cards) && deck.cards[0] && Array.isArray(deck.cards[0].children));
+}
+
+module.exports = {
+    validatePaperSlideDeck,
+    validatePaperSlideDeckV2,
+    isV2LayoutTreeDeck,
+    V2_ALLOWED_ELEMENTS,
+    VALID_THEMES,
+    THEME_VARIANTS,
+    VALID_KINDS,
+    // Caps + payload helpers — exported for unit tests and so the slice
+    // validator in slice.js can mirror the same shape rules without drift.
+    validateQuotePayload,
+    validateDataPayload,
+    validateListPayload,
+    QUOTE_TEXT_MAX,
+    QUOTE_ATTRIBUTION_MAX,
+    DATA_VALUE_MAX,
+    DATA_UNIT_MAX,
+    DATA_LABEL_MAX,
+    LIST_ITEM_MAX_LEN,
+    LIST_ITEM_MIN_COUNT,
+    LIST_ITEM_MAX_COUNT,
+};