@neatico/visual-core 0.14.26 → 0.14.64

package/dist/cjs/recipeParameters.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECIPE_PARAMETER_CONTRACTS = void 0;
+exports.recipeParameterContract = recipeParameterContract;
+const nativeSocialParameters_js_1 = require("./nativeSocialParameters.js");
+const textPresentation_js_1 = require("./textPresentation.js");
+const designSystem_js_1 = require("./designSystem.js");
+const text = (description, maxLength = 600) => ({
+    type: "string",
+    description,
+    maxLength,
+});
+const object = (properties, required) => ({
+    type: "object",
+    additionalProperties: false,
+    properties,
+    required,
+});
+const array = (items, minItems, maxItems) => ({ type: "array", items, minItems, maxItems });
+const evidence = array(object({
+    sourceId: text("Existing source segment ID.", 160),
+    quote: text("Exact source quotation.", 2000),
+}, ["sourceId"]), 1, 32);
+const base = (kind, properties, required) => object({
+    id: text("Stable block ID, unique within this page.", 80),
+    kind: { const: kind },
+    evidence,
+    ...properties,
+}, ["id", "kind", "evidence", ...required]);
+const descriptions = {
+    paragraph: "Explain a narrative idea with readable prose and optional section headings.",
+    features: "Present parallel capabilities or a list of distinct ideas without implying a sequence.",
+    steps: "Explain ordered actions or a chronological sequence supported by the source.",
+    comparison: "Compare supplied alternatives with aligned criteria; never invent a competing alternative.",
+    parameters: "Present exact specifications, logistics, identifiers, dates, prices, or named facts.",
+    quote: "Emphasize a verbatim quotation with its supplied attribution.",
+    chart: "Explain a comparable numeric series with source-backed values and a shared unit.",
+    code: "Display exact source code without rewriting identifiers, literals, or line breaks.",
+    image: "Arrange a real, previously supplied image asset with its source reference and focal subject.",
+};
+function blockSchema(kind, maximum) {
+    const count = Math.max(1, Math.min(12, maximum || 12));
+    switch (kind) {
+        case "paragraph":
+            return base(kind, {
+                text: text("Source-faithful prose.", 2000),
+                heading: text("Optional source-supported heading.", 120),
+                level: { enum: [2, 3] },
+            }, ["text"]);
+        case "features":
+        case "steps":
+            return base(kind, {
+                entries: array(object({
+                    title: text("Concise item label without an ordinal prefix.", 120),
+                    description: text("Source-faithful explanation; omit filler.", 600),
+                }, ["title", "description"]), 1, count),
+            }, ["entries"]);
+        case "comparison":
+            return base(kind, {
+                columns: array(object({
+                    title: text("A supplied alternative.", 120),
+                    points: array(text("Source-backed comparison criterion.", 600), 1, 8),
+                    price: text("Exact source price, only when supplied.", 120),
+                    values: array(text("Exact value aligned with points.", 160), 1, 8),
+                    statuses: array({ enum: ["included", "excluded", "partial", "unknown"] }, 1, 8),
+                }, ["title", "points"]), 2, Math.max(2, Math.min(4, count))),
+            }, ["columns"]);
+        case "parameters":
+            return base(kind, {
+                rows: array(object({
+                    name: text("Fact name.", 120),
+                    value: text("Exact source value.", 300),
+                    description: text("Source-supported qualification, otherwise an empty string.", 600),
+                }, ["name", "value", "description"]), 1, count),
+            }, ["rows"]);
+        case "quote":
+            return base(kind, {
+                text: text("Verbatim source quotation.", 1200),
+                attribution: text("Exact source attribution.", 160),
+                role: text("Role only when explicitly supplied.", 160),
+                avatarAssetId: text("Existing supplied portrait asset ID; never invent a person or image.", 160),
+            }, ["text", "attribution"]);
+        case "chart":
+            return base(kind, {
+                chart: { enum: ["bar", "line"] },
+                unit: text("Exact source unit.", 80),
+                values: array(object({
+                    label: text("Exact source label.", 120),
+                    value: { type: "number" },
+                }, ["label", "value"]), 2, 12),
+            }, ["chart", "unit", "values"]);
+        case "code":
+            return base(kind, {
+                sourceId: text("Existing code source ID; code remains unchanged.", 160),
+                language: text("Source code language.", 80),
+                code: text("Exact source code.", 20000),
+            }, ["sourceId", "language", "code"]);
+        case "image":
+            return base(kind, {
+                sourceId: text("Existing image source ID.", 160),
+                assetId: text("Existing asset ID; no generated URLs.", 160),
+                alt: text("Subject and purpose of the supplied image.", 600),
+                treatment: { enum: ["screenshot", "photograph", "diagram"] },
+                status: { enum: ["available", "missing"] },
+            }, ["sourceId", "alt", "treatment", "status"]);
+    }
+}
+/** Each authored renderer receives a fixed block sequence and bounded copy. */
+function fixedBlocks(recipe) {
+    const id = recipe.id;
+    let kinds;
+    if (id.endsWith("ledger-chart"))
+        kinds = ["parameters", "chart"];
+    else if (id.endsWith("detail-sidebar"))
+        kinds = ["paragraph", "parameters"];
+    else if (id.endsWith("technical-log"))
+        kinds = ["paragraph", "code"];
+    else if (id.endsWith("architecture-stack"))
+        kinds = ["steps", "paragraph"];
+    else if (["authored-mechanism-flow", "authored-reference-capability-map"].includes(id))
+        kinds = ["features", "paragraph"];
+    else if (id === "authored-founder-timeline")
+        kinds = ["steps", "paragraph"];
+    else if (id === "authored-founder-comparison")
+        kinds = ["comparison", "paragraph"];
+    else if (id === "semantic-hero-editorial")
+        kinds = ["paragraph", "paragraph", "paragraph", "image"];
+    else if (id.endsWith("speaker-lineup"))
+        kinds = ["parameters", "quote", "quote", "quote"];
+    else if (id.endsWith("speaker-spotlight"))
+        kinds = ["parameters", "quote"];
+    else if (id === "authored-reference-story")
+        kinds = ["image", "paragraph", "features"];
+    else if (id === "authored-reference-photo")
+        kinds = ["paragraph", "image"];
+    else if (id === "authored-image-triptych")
+        kinds = ["paragraph", "features", "paragraph", "image"];
+    else if (recipe.requiresImage && recipe.accepts.includes("image"))
+        kinds = ["image"];
+    else if (recipe.family === "mixed-stack")
+        kinds = ["features"];
+    else
+        kinds = [
+            recipe.accepts.find((kind) => kind !== "paragraph" && kind !== "image") ||
+                "paragraph",
+        ];
+    if (id.startsWith("bookend-") || recipe.family.startsWith("prose-"))
+        kinds = ["paragraph"];
+    const items = kinds.map((kind) => {
+        const schema = JSON.parse(JSON.stringify(blockSchema(kind, recipe.maxEntries)));
+        const fields = schema.properties;
+        const count = Math.max(recipe.minEntries || 1, Math.min(3, recipe.maxEntries || 3));
+        if (kind === "paragraph")
+            fields.text.maxLength =
+                ["authored-reference-detail-sidebar", "authored-reference-diagonal", "authored-prose-inset"].includes(id) ? 160 : 120;
+        if (kind === "features" || kind === "steps") {
+            const entries = fields.entries;
+            entries.minItems = id === "authored-reference-story" ? 2 : count;
+            entries.maxItems = count;
+            entries.items.properties.illustration = {
+                type: "string",
+                enum: [...nativeSocialParameters_js_1.COMPOSITION_ILLUSTRATIONS, "symbol"],
+                default: "structure",
+                description: "Editable native illustration for the item. Choose the visual concept that explains its meaning. This field controls a graphic, not prose.",
+            };
+            entries.items.required.push("illustration");
+            entries.items.properties.icon = { type: "string", enum: ["BsJournalText", "BsPersonCheck", "BsShare", "BsPeople", "BsSearch", "BsShieldCheck", "BsBarChart", "BsCodeSlash", "BsSignpostSplit", "BsCheck2Circle", "BsFolder2Open", "BsGrid1X2"], description: "Optional authored icon variant; illustration remains the primary visual concept." };
+            entries.items.properties.title.maxLength = 28;
+            entries.items.properties.description.maxLength =
+                id === "authored-feature-focus" ? 160 : 48;
+            if (/(?:reference-faq|editorial-faq)$/.test(id) || id === "faq")
+                entries.items.properties.title.pattern = "^.+[?？]$";
+        }
+        if (kind === "parameters") {
+            const rows = id.endsWith("ledger-chart") ||
+                id.endsWith("detail-sidebar") ||
+                id.includes("speaker-")
+                ? 2
+                : count;
+            fields.rows.minItems = id.endsWith("speaker-lineup") ? 1 : id === "pricing" ? 2 : rows;
+            fields.rows.maxItems = rows;
+            fields.rows.items.properties.name.maxLength = 20;
+            fields.rows.items.properties.value.maxLength = 24;
+            fields.rows.items.properties.description.maxLength = 64;
+            if (id.includes("speaker-"))
+                fields.rows.items.properties.description = { const: "" };
+        }
+        if (kind === "comparison") {
+            fields.columns.minItems = 2;
+            fields.columns.maxItems = 2;
+            const column = fields.columns.items.properties;
+            column.title.maxLength = 20;
+            column.points.minItems = id === "authored-founder-comparison" ? 1 : 2;
+            column.points.maxItems = 3;
+            column.points.items.maxLength = id === "authored-founder-comparison" ? 64 : 40;
+            column.values.maxItems = 3;
+            column.values.items.maxLength = 16;
+            column.values.minItems = 0;
+            column.statuses.minItems = 0;
+            column.statuses.maxItems = 3;
+            column.price.maxLength = 24;
+        }
+        if (kind === "quote") {
+            fields.text.maxLength = id.includes("speaker-") ? 48 : 160;
+            fields.attribution.maxLength = 32;
+            if (id.includes("speaker-")) {
+                fields.avatarAssetId.description =
+                    "An existing portrait asset ID, or neatico-editorial-placeholder for an original source-attributed illustration.";
+                schema.required.push("avatarAssetId");
+            }
+        }
+        if (kind === "code") {
+            fields.code.maxLength = 400;
+            fields.code.description =
+                "A concise exact source excerpt, or a clearly labeled illustrative example when no source code exists. At most eight lines and 56 columns per line.";
+            fields.code.pattern = String.raw `^(?:[^\n]{0,56}\n){0,7}[^\n]{0,56}$`;
+        }
+        if (kind === "image")
+            fields.alt.maxLength = 80;
+        if (kind === "chart") {
+            const count = id.endsWith("ledger-chart") ? 3 : 4;
+            fields.values.minItems = Math.min(3, count);
+            fields.values.maxItems = count;
+            fields.values.items.properties.label.maxLength = 20;
+            fields.unit.maxLength = 24;
+            if (/trend/.test(id))
+                fields.chart = { const: "line" };
+            if (/bars|ledger-chart/.test(id))
+                fields.chart = { const: "bar" };
+            if (/donut|reference-share|reference-metrics/.test(id)) {
+                fields.chart = { const: "bar" };
+                fields.unit = { type: "string", maxLength: 24, pattern: "%", description: "Percentage unit, optionally qualified as illustrative or simulated." };
+                fields.values.description =
+                    "Nonnegative shares totaling exactly 100. Use labeled illustrative shares when the input has no comparable numbers.";
+                fields.values.items.properties.value.minimum = 0;
+                fields.values.items.properties.value.maximum = 100;
+            }
+        }
+        return schema;
+    });
+    return {
+        type: "array",
+        items,
+        minItems: items.length,
+        maxItems: items.length,
+        additionalItems: false,
+        description: "Fixed ordered parameters for this renderer. Return every block exactly once in this order; do not add explanatory blocks.",
+    };
+}
+/** Fixed renderer parameters, not executable layout trees. The complete schema
+ * travels with each formal generation batch; summaries are scheduling aids only.
+ */
+function recipeParameterContract(recipe, supportedKinds = [recipe.kind]) {
+    return {
+        id: recipe.id,
+        schemaVersion: 1,
+        supportedKinds,
+        semanticDescription: recipe.accepts
+            .map((kind) => descriptions[kind])
+            .join(" "),
+        scenes: recipe.scenes || [],
+        rendererKey: `${recipe.renderer}:${recipe.id}`,
+        capacity: {
+            minEntries: recipe.minEntries,
+            maxEntries: recipe.maxEntries,
+            requiresImage: recipe.requiresImage,
+        },
+        parameterSchema: object({
+            title: {
+                ...text("Audience-facing headline preserving the original topic.", 64),
+                minLength: 1,
+            },
+            blocks: fixedBlocks(recipe),
+            textPresentation: (0, textPresentation_js_1.textPresentationSchema)(),
+        }, ["title", "blocks"]),
+        importance: { title: 3, blocks: 7 },
+        generationPolicy: {
+            title: ["user-fact", "derived", "creative"],
+            blocks: ["user-fact", "derived", "creative", "simulated"],
+            assets: ["existing-reference-only"],
+        },
+        fallbackPolicy: {
+            missingContent: "derive-or-labeled-example",
+            missingAsset: "search-or-native-placeholder",
+            omitCandidate: false,
+        },
+        themeBindings: [
+            "palette.background",
+            "palette.surface",
+            "palette.ink",
+            "palette.muted",
+            "palette.accent",
+            "palette.line",
+            "typography.heading",
+            "typography.body",
+            "typography.code",
+            "geometry",
+        ],
+    };
+}
+/** Shared recipes are one part of the formal catalog; host-specific renderer
+ * definitions register through the same contract constructor during migration.
+ */
+exports.RECIPE_PARAMETER_CONTRACTS = designSystem_js_1.DESIGN_RECIPES.filter((recipe, index, recipes) => recipes.findIndex((other) => other.id === recipe.id) === index).map((recipe) => recipeParameterContract(recipe, designSystem_js_1.DESIGN_RECIPES.filter((other) => other.id === recipe.id).map((other) => other.kind)));

package/dist/cjs/styleManifest.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStyleManifest = createStyleManifest;
+exports.validateStyleManifest = validateStyleManifest;
+const designSystem_js_1 = require("./designSystem.js");
+const fontCatalog_js_1 = require("./fontCatalog.js");
+function createStyleManifest(themeId, copy = "", imagery) {
+    const theme = (0, designSystem_js_1.designTheme)(themeId);
+    if (!designSystem_js_1.DESIGN_THEMES.some((candidate) => candidate.id === themeId) &&
+        !["paper", "midnight", "ocean", "plum"].includes(themeId))
+        throw new Error("STYLE_UNKNOWN_THEME");
+    const manifest = {
+        version: 1,
+        themeId: theme.id,
+        themeVersion: 1,
+        theme: {
+            ...theme,
+            palette: { ...theme.palette },
+            typography: { ...theme.typography },
+            geometry: { ...theme.geometry },
+        },
+        fonts: {
+            heading: (0, fontCatalog_js_1.languageFont)(copy, theme.typography.heading),
+            body: (0, fontCatalog_js_1.languageFont)(copy, theme.typography.body),
+            code: theme.typography.code === "monospace"
+                ? "JetBrains Mono"
+                : theme.typography.code,
+        },
+        imagery: {
+            medium: "native",
+            referenceAssetIds: [],
+            direction: "",
+            ...imagery,
+        },
+    };
+    return validateStyleManifest(manifest);
+}
+function validateStyleManifest(value) {
+    const manifest = value;
+    const fail = () => {
+        throw new Error("STYLE_INVALID_MANIFEST");
+    };
+    if (!manifest ||
+        manifest.version !== 1 ||
+        manifest.themeVersion !== 1 ||
+        typeof manifest.themeId !== "string" ||
+        !manifest.theme ||
+        manifest.theme.id !== manifest.themeId ||
+        !designSystem_js_1.DESIGN_THEMES.some((theme) => theme.id === manifest.themeId))
+        return fail();
+    const { palette, typography, geometry } = manifest.theme;
+    if (!palette ||
+        ["background", "surface", "ink", "muted", "accent", "line"].some((key) => !/^#[\da-f]{6}$/i.test(palette[key] || "")))
+        return fail();
+    if (!typography ||
+        ["heading", "body", "code"].some((key) => typeof typography[key] !==
+            "string") ||
+        !Number.isInteger(typography.headingWeight) ||
+        typography.headingWeight < 100 ||
+        typography.headingWeight > 900)
+        return fail();
+    if (!geometry ||
+        !Number.isFinite(geometry.radius) ||
+        geometry.radius < 0 ||
+        geometry.radius > 100 ||
+        !Number.isFinite(geometry.spacing) ||
+        geometry.spacing <= 0 ||
+        geometry.spacing > 4 ||
+        !["none", "hairline", "accent"].includes(geometry.rule))
+        return fail();
+    if (!manifest.fonts ||
+        Object.keys(manifest.fonts).length !== 3 ||
+        ["heading", "body", "code"].some((key) => {
+            const font = manifest.fonts[key];
+            return typeof font !== "string" || !font.trim() || font.length > 100;
+        }))
+        return fail();
+    if (!manifest.imagery ||
+        !["native", "photography", "illustration", "3d"].includes(manifest.imagery.medium) ||
+        typeof manifest.imagery.direction !== "string" ||
+        manifest.imagery.direction.length > 2000 ||
+        !Array.isArray(manifest.imagery.referenceAssetIds) ||
+        manifest.imagery.referenceAssetIds.length > 16 ||
+        manifest.imagery.referenceAssetIds.some((id) => typeof id !== "string" || !id || id.length > 160))
+        return fail();
+    return {
+        version: 1,
+        themeId: manifest.themeId,
+        themeVersion: 1,
+        theme: {
+            id: manifest.themeId,
+            palette: { ...palette },
+            typography: { ...typography },
+            geometry: { ...geometry },
+        },
+        fonts: {
+            heading: manifest.fonts.heading,
+            body: manifest.fonts.body,
+            code: manifest.fonts.code,
+        },
+        imagery: {
+            medium: manifest.imagery.medium,
+            direction: manifest.imagery.direction,
+            referenceAssetIds: [...manifest.imagery.referenceAssetIds],
+        },
+    };
+}

package/dist/cjs/textPresentation.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textPresentationSchema = textPresentationSchema;
+exports.validateTextPresentations = validateTextPresentations;
+const object = (properties) => ({
+    type: 'object', additionalProperties: false, properties, required: Object.keys(properties),
+});
+function textPresentationSchema() {
+    return {
+        type: 'array', minItems: 0, maxItems: 8, default: [],
+        description: 'Optional typography for visible text fields, including title, body, item descriptions and quotations. Use a few deliberate contrasts within the shared suite. Every line must preserve the original field text and word boundaries. Empty uses the authored typography. Never style code, evidence, IDs or asset metadata.',
+        items: object({
+            path: { type: 'string', minLength: 1, maxLength: 120, description: 'Exact dot path of the visible text field, such as body, items.0.description or blocks.0.text.' },
+            fit: { type: 'string', enum: ['natural', 'equal-width'], description: 'Equal-width adjusts each line independently within readable size limits; it never stretches glyphs.' },
+            lines: { type: 'array', minItems: 1, maxItems: 8, items: object({
+                    text: { type: 'string', minLength: 1, maxLength: 220, description: 'One complete phrase copied exactly from the target field. All lines together must preserve that entire field.' },
+                    font: { type: 'string', enum: ['display', 'body', 'mono'] },
+                    scale: { type: 'number', minimum: 0.8, maximum: 1.35 },
+                    tone: { type: 'string', enum: ['ink', 'accent', 'secondary'] },
+                    decoration: { type: 'string', enum: ['none', 'marker', 'underline'] },
+                    italic: { type: 'boolean' },
+                }) },
+        }),
+    };
+}
+const normalize = (text) => text.normalize('NFC').replace(/\s+/gu, ' ').trim();
+const word = (character) => /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Number}]/u.test(character);
+/** Validate exact source reconstruction; script-aware boundaries permit CJK breaks. */
+function validateTextPresentations(value, content) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 8)
+        throw new Error('TEXT_PRESENTATION_INVALID');
+    const paths = new Set();
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        if (Object.keys(entry).some(key => !['path', 'fit', 'lines'].includes(key)))
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        if (typeof entry.path !== 'string' || !/^(?:title|body|eyebrow|cta|value|attribution|(?:items|blocks)\.\d+\.(?:(?:entries|rows|columns)\.\d+\.)?(?:title|heading|text|description|name|value|attribution|points\.\d+))$/.test(entry.path) || paths.has(entry.path))
+            throw new Error('TEXT_PRESENTATION_PATH');
+        paths.add(entry.path);
+        const copy = entry.path.split('.').reduce((node, key) => node?.[key], content);
+        if (typeof copy !== 'string' || !copy.trim())
+            throw new Error('TEXT_PRESENTATION_PATH');
+        if (!['natural', 'equal-width'].includes(entry.fit) || !Array.isArray(entry.lines) || entry.lines.length < 1 || entry.lines.length > 8)
+            throw new Error('TEXT_PRESENTATION_INVALID');
+        const source = normalize(copy);
+        let cursor = 0;
+        for (const line of entry.lines) {
+            if (!line || typeof line !== 'object' || Array.isArray(line) || Object.keys(line).some(key => !['text', 'font', 'scale', 'tone', 'decoration', 'italic'].includes(key)))
+                throw new Error('TEXT_PRESENTATION_INVALID');
+            if (typeof line.text !== 'string' || !normalize(line.text) || Array.from(line.text).length > 220 || !['display', 'body', 'mono'].includes(line.font) || !Number.isFinite(line.scale) || line.scale < 0.8 || line.scale > 1.35 || !['ink', 'accent', 'secondary'].includes(line.tone) || !['none', 'marker', 'underline'].includes(line.decoration) || typeof line.italic !== 'boolean')
+                throw new Error('TEXT_PRESENTATION_INVALID');
+            const phrase = normalize(line.text);
+            if (source[cursor] === ' ')
+                cursor++;
+            if (!source.startsWith(phrase, cursor))
+                throw new Error('TEXT_PRESENTATION_CONTENT');
+            if (cursor && source[cursor - 1] !== ' ' && word(source[cursor - 1]) && word(phrase[0]))
+                throw new Error('TEXT_PRESENTATION_WORD_BOUNDARY');
+            cursor += phrase.length;
+        }
+        if (cursor !== source.length)
+            throw new Error('TEXT_PRESENTATION_CONTENT');
+    }
+    return value;
+}

package/dist/compositionNumbers.d.ts

@@ -0,0 +1,4 @@
+/** Stable public display numbers, independent of runtime registration order. */
+export declare const SEMANTIC_DISPLAY_NUMBERS: Readonly<Record<string, string>>;
+/** Social numbers follow the established formal gallery, not registration order. */
+export declare const SOCIAL_DISPLAY_NUMBERS: Readonly<Record<string, string>>;

package/dist/compositionNumbers.js

@@ -0,0 +1,108 @@
+/** Stable public display numbers, independent of runtime registration order. */
+export const SEMANTIC_DISPLAY_NUMBERS = {
+    "semantic:presentation:bookend-cover-editorial": "M001",
+    "semantic:presentation:bookend-cover-panel": "M002",
+    "semantic:presentation:bookend-cover-split": "M003",
+    "semantic:presentation:bookend-closing-editorial": "M004",
+    "semantic:presentation:bookend-closing-panel": "M005",
+    "semantic:presentation:bookend-closing-split": "M006",
+    "semantic:presentation:brand-collection-grid": "M007",
+    "semantic:social:time-notice": "M099",
+    "semantic:social:ticket": "M100",
+    "semantic:social:webinar": "M101",
+    "semantic:social:pricing": "M102",
+    "semantic:social:offer": "M103",
+    "semantic:social:hiring": "M104",
+    "semantic:social:community": "M105",
+    "semantic:social:menu": "M106",
+    "semantic:social:itinerary": "M107",
+    "semantic:social:schedule": "M108",
+    "semantic:presentation:authored-plan-cards": "M109",
+    "semantic:presentation:authored-image-banner": "M009",
+    "semantic:presentation:authored-image-split": "M010",
+    "semantic:presentation:authored-image-editorial": "M011",
+    "semantic:presentation:authored-image-campaign": "M012",
+    "semantic:presentation:authored-image-inset": "M013",
+    "semantic:presentation:authored-prose-inset": "M014",
+    "semantic:presentation:authored-feature-focus": "M015",
+    "semantic:presentation:authored-feature-bento": "M016",
+    "semantic:presentation:authored-feature-index": "M017",
+    "semantic:presentation:authored-steps-journey": "M018",
+    "semantic:presentation:authored-steps-ribbon": "M019",
+    "semantic:presentation:authored-comparison-panels": "M020",
+    "semantic:presentation:authored-quote-editorial": "M021",
+    "semantic:presentation:authored-quote-poster": "M022",
+    "semantic:presentation:authored-code-editorial": "M023",
+    "semantic:presentation:authored-parameter-ledger": "M024",
+    "semantic:presentation:authored-parameter-cards": "M025",
+    "semantic:presentation:semantic-code-split": "M026",
+    "semantic:presentation:semantic-parameters-split": "M029",
+    "semantic:presentation:semantic-parameters-stack": "M030",
+    "semantic:presentation:semantic-steps-split": "M032",
+    "semantic:presentation:semantic-steps-stack": "M033",
+    "semantic:presentation:semantic-steps-editorial": "M034",
+    "semantic:presentation:semantic-comparison-split": "M035",
+    "semantic:presentation:semantic-features-split": "M038",
+    "semantic:presentation:semantic-features-stack": "M039",
+    "semantic:presentation:semantic-features-editorial": "M040",
+    "semantic:presentation:semantic-quote-split": "M041",
+    "semantic:presentation:semantic-chart-split": "M044",
+    "semantic:presentation:semantic-chart-stack": "M045",
+    "semantic:presentation:semantic-prose-split": "M050",
+    "semantic:presentation:semantic-prose-stack": "M051",
+    "semantic:presentation:semantic-prose-editorial": "M052",
+    "semantic:presentation:semantic-mixed-stack": "M053",
+    "semantic:social:semantic-hero-editorial": "M094"
+};
+/** Social numbers follow the established formal gallery, not registration order. */
+export const SOCIAL_DISPLAY_NUMBERS = {
+    "note-question": "S001",
+    "note-marker": "S002",
+    "note-editorial": "S003",
+    "note-checklist": "S004",
+    "note-photo": "S005",
+    "note-news": "S006",
+    "chat-messenger": "S007",
+    "chat-imessage": "S008",
+    "chat-telegram": "S009",
+    "chat-workplace": "S010",
+    "time-notice": "S011",
+    "news-focus": "S012",
+    "usage-breakdown": "S013",
+    "organization": "S014",
+    "editorial-quote": "S015",
+    "research-highlight": "S016",
+    "product-showcase": "S017",
+    "manifesto": "S018",
+    "launch": "S019",
+    "bento": "S020",
+    "spotlight": "S021",
+    "ticket": "S022",
+    "webinar": "S023",
+    "quote": "S024",
+    "testimonial": "S025",
+    "metric": "S026",
+    "report": "S027",
+    "checklist": "S028",
+    "steps": "S029",
+    "comparison": "S030",
+    "myth": "S031",
+    "pricing": "S032",
+    "offer": "S033",
+    "editorial": "S034",
+    "story": "S035",
+    "hiring": "S036",
+    "team": "S037",
+    "course": "S038",
+    "case-study": "S039",
+    "notice": "S040",
+    "community": "S041",
+    "menu": "S042",
+    "specification": "S043",
+    "itinerary": "S044",
+    "schedule": "S045",
+    "safety": "S046",
+    "faq": "S047",
+    "split-bar-compare": "S048",
+    "benchmark-bars": "S049"
+};

package/dist/compositionUseCases.d.ts

@@ -0,0 +1 @@
+export declare function compositionUseCase(id: string): string;