@neatico/visual-core 0.14.3 → 0.14.64

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/text.js

@@ -28,7 +28,7 @@ function wrapCopy(text, width, size, bold, measure, options = {}) {
         }
         const ranges = options.keepWords && typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'word' }).segment(paragraph)].filter(part => part.isWordLike).map(part => ({ start: part.index, end: part.index + part.segment.length, text: part.segment })) : [];
         // Keep a fitting URL/API token whole even where UAX permits a slash break.
-        for (const match of paragraph.matchAll(/[A-Za-z0-9]+(?:[._/@+\-][A-Za-z0-9]+)+/g))
+        for (const match of paragraph.matchAll(/[A-Za-z0-9]+(?:[.:_/@+\-][A-Za-z0-9]+)+/g))
             ranges.push({ start: match.index, end: match.index + match[0].length, text: match[0] });
         const wrapAt = (available) => {
             const breaker = new linebreak_1.default(paragraph), tokens = [];
@@ -56,7 +56,17 @@ function wrapCopy(text, width, size, bold, measure, options = {}) {
                     line = token.trimStart();
                     continue;
                 }
-                const glyphs = typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(token)].map(part => part.segment) : Array.from(token);
+                const graphemes = (value) => typeof Intl.Segmenter === 'function' ? [...new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(value)].map(part => part.segment) : Array.from(value);
+                // A range may be wider than a column, but a fitting clock must stay intact.
+                // Keep each clock as an atomic fallback unit instead of splitting its minutes.
+                const glyphs = [];
+                let cursor = 0;
+                for (const match of token.matchAll(/\d{1,2}:\d{2}(?::\d{2})?/g)) {
+                    glyphs.push(...graphemes(token.slice(cursor, match.index)));
+                    glyphs.push(...(measured(match[0]) <= available ? [match[0]] : graphemes(match[0])));
+                    cursor = match.index + match[0].length;
+                }
+                glyphs.push(...graphemes(token.slice(cursor)));
                 for (const glyph of glyphs) {
                     if (glyph.trim() && measured(glyph) > available)
                         throw new RangeError('A character exceeds the available width');

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/composition.d.ts

@@ -1,11 +1,11 @@
 /** Versioned data-only composition: executable CSS, HTML and URLs are not accepted. */
 export type CompositionNode = {
-    type: 'row' | 'column' | 'text' | 'image' | 'divider' | 'icon';
+    type: "row" | "column" | "text" | "image" | "divider" | "icon";
     weight?: number;
-    tone?: 'plain' | 'card' | 'contrast';
-    role?: 'hero' | 'heading' | 'body' | 'caption';
+    tone?: "plain" | "card" | "contrast";
+    role?: "hero" | "heading" | "body" | "caption";
     bind?: string;
-    icon?: 'idea' | 'check' | 'chart' | 'people' | 'shield' | 'arrow';
+    icon?: "idea" | "check" | "chart" | "people" | "shield" | "arrow";
     children?: CompositionNode[];
 };
 export interface Composition {

package/dist/composition.js

@@ -1,18 +1,29 @@
 export const COMPOSITION_PROMPT = `Also return composition:{version:1,root:node}. Design a hierarchy from the content, not a fixed template. A node is {type,weight?,tone?,role?,bind?,icon?,children?}. row and column contain 2-4 children; nest up to 5 levels, at most 40 nodes. Weight is relative space 0.5-4. Tone plain/card/contrast applies to groups. Text binds exactly one existing nonempty content field (title or headline, body, eyebrow, cta, value, attribution, items.0.title, items.0.description, etc); never bind notes. Include EVERY nonempty content field exactly once. Text role hero/heading/body/caption controls typography. Image is an optional original conceptual illustration, not invented evidence or a photo. Icon optionally uses idea/check/chart/people/shield/arrow. Divider separates related content. No coordinates, CSS, HTML, URLs or text in the tree. Use one strong hero, purposeful contrast, asymmetric columns, grouped evidence, and breathing room. Rows reflow for narrow formats. Different stories should have different trees, not just different colors.`;
 export function compositionFields(value) {
     const fields = {};
-    for (const key of ['title', 'headline', 'body', 'eyebrow', 'cta', 'value', 'attribution'])
-        if (typeof value[key] === 'string' && value[key].trim())
+    for (const key of [
+        "title",
+        "headline",
+        "body",
+        "eyebrow",
+        "cta",
+        "value",
+        "attribution",
+    ])
+        if (typeof value[key] === "string" && value[key].trim())
             fields[key] = value[key];
     if (Array.isArray(value.items))
-        value.items.forEach((item, i) => { if (!item || typeof item !== 'object')
-            return; for (const key of ['title', 'description']) {
-            if (!Object.prototype.hasOwnProperty.call(item, key))
-                continue;
-            const v = item[key];
-            if (typeof v === 'string' && v.trim())
-                fields[`items.${i}.${key}`] = v;
-        } });
+        value.items.forEach((item, i) => {
+            if (!item || typeof item !== "object")
+                return;
+            for (const key of ["title", "description"]) {
+                if (!Object.prototype.hasOwnProperty.call(item, key))
+                    continue;
+                const v = item[key];
+                if (typeof v === "string" && v.trim())
+                    fields[`items.${i}.${key}`] = v;
+            }
+        });
     return fields;
 }
 export function validateComposition(raw, fields) {
@@ -20,44 +31,59 @@ export function validateComposition(raw, fields) {
     let count = 0, images = 0;
     const seen = new Set();
     if (!value || value.version !== 1)
-        throw new Error('Unsupported composition');
+        throw new Error("Unsupported composition");
     function visit(n, depth) {
-        if (!n || typeof n !== 'object' || ++count > 40 || depth > 5 || !['row', 'column', 'text', 'image', 'divider', 'icon'].includes(n.type))
-            throw new Error('Invalid composition node');
-        if (n.weight !== undefined && (!Number.isFinite(n.weight) || n.weight < .5 || n.weight > 4))
-            throw new Error('Invalid composition weight');
-        if (n.tone !== undefined && !['plain', 'card', 'contrast'].includes(n.tone))
-            throw new Error('Invalid composition tone');
-        const out = { type: n.type, weight: n.weight, tone: n.tone };
-        if (n.type === 'row' || n.type === 'column') {
-            if (!Array.isArray(n.children) || n.children.length < 2 || n.children.length > 4)
-                throw new Error('Invalid composition group');
-            out.children = n.children.map(c => visit(c, depth + 1));
+        if (!n ||
+            typeof n !== "object" ||
+            ++count > 40 ||
+            depth > 5 ||
+            !["row", "column", "text", "image", "divider", "icon"].includes(n.type))
+            throw new Error("Invalid composition node");
+        if (n.weight !== undefined &&
+            (!Number.isFinite(n.weight) || n.weight < 0.5 || n.weight > 4))
+            throw new Error("Invalid composition weight");
+        if (n.tone !== undefined && !["plain", "card", "contrast"].includes(n.tone))
+            throw new Error("Invalid composition tone");
+        const out = {
+            type: n.type,
+            weight: n.weight,
+            tone: n.tone,
+        };
+        if (n.type === "row" || n.type === "column") {
+            if (!Array.isArray(n.children) ||
+                n.children.length < 2 ||
+                n.children.length > 4)
+                throw new Error("Invalid composition group");
+            out.children = n.children.map((c) => visit(c, depth + 1));
         }
         else {
             if (n.children !== undefined)
-                throw new Error('Leaf cannot have children');
-            if (n.type === 'text') {
-                if (!n.bind || !Object.prototype.hasOwnProperty.call(fields, n.bind) || seen.has(n.bind))
-                    throw new Error('Invalid or duplicated binding');
-                if (n.role !== undefined && !['hero', 'heading', 'body', 'caption'].includes(n.role))
-                    throw new Error('Invalid text role');
+                throw new Error("Leaf cannot have children");
+            if (n.type === "text") {
+                if (!n.bind ||
+                    !Object.prototype.hasOwnProperty.call(fields, n.bind) ||
+                    seen.has(n.bind))
+                    throw new Error("Invalid or duplicated binding");
+                if (n.role !== undefined &&
+                    !["hero", "heading", "body", "caption"].includes(n.role))
+                    throw new Error("Invalid text role");
                 seen.add(n.bind);
                 out.bind = n.bind;
-                out.role = n.role || 'body';
+                out.role = n.role || "body";
             }
-            if (n.type === 'image' && ++images > 1)
-                throw new Error('Only one illustration per composition');
-            if (n.type === 'icon') {
-                if (!n.icon || !['idea', 'check', 'chart', 'people', 'shield', 'arrow'].includes(n.icon))
-                    throw new Error('Invalid icon');
+            if (n.type === "image" && ++images > 1)
+                throw new Error("Only one illustration per composition");
+            if (n.type === "icon") {
+                if (!n.icon ||
+                    !["idea", "check", "chart", "people", "shield", "arrow"].includes(n.icon))
+                    throw new Error("Invalid icon");
                 out.icon = n.icon;
             }
         }
         return out;
     }
     const root = visit(value.root, 0);
-    if (Object.keys(fields).some(key => !seen.has(key)))
-        throw new Error('Composition omits content');
+    if (Object.keys(fields).some((key) => !seen.has(key)))
+        throw new Error("Composition omits content");
     return { version: 1, root };
 }

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/compositionScenes.d.ts

@@ -1,11 +1,11 @@
-import type { SemanticKind } from './content.js';
+import type { SemanticKind } from "./content.js";
 /** Product scenes describe user intent; recipes describe an executable composition.
  * Multiple scenes deliberately reuse a recipe. Scene count is not design count.
  */
 export interface CompositionScene {
     id: string;
     kinds: readonly SemanticKind[];
-    outputs: readonly ('presentation' | 'social')[];
+    outputs: readonly ("presentation" | "social")[];
     requiresAsset?: boolean;
 }
 export declare const COMPOSITION_SCENES: readonly CompositionScene[];

package/dist/compositionScenes.js

@@ -1,47 +1,100 @@
-const both = ['presentation', 'social'];
+const both = ["presentation", "social"];
 export const COMPOSITION_SCENES = [
-    { id: 'brand-collection', kinds: ['features'], outputs: both },
-    { id: 'hero', kinds: ['paragraph'], outputs: both }, { id: 'chapter', kinds: ['paragraph'], outputs: ['presentation'] },
-    { id: 'statement', kinds: ['paragraph'], outputs: both }, { id: 'closing', kinds: ['paragraph'], outputs: both },
-    { id: 'product-launch', kinds: ['features'], outputs: both }, { id: 'feature-spotlight', kinds: ['features'], outputs: both },
-    { id: 'feature-overview', kinds: ['features'], outputs: both }, { id: 'benefits', kinds: ['features'], outputs: both },
-    { id: 'comparison', kinds: ['comparison'], outputs: both }, { id: 'before-after', kinds: ['comparison'], outputs: both },
-    { id: 'plan-options', kinds: ['comparison'], outputs: both }, { id: 'process', kinds: ['steps'], outputs: both },
-    { id: 'roadmap', kinds: ['steps'], outputs: both }, { id: 'tutorial', kinds: ['steps'], outputs: both },
-    { id: 'checklist', kinds: ['features'], outputs: both }, { id: 'metrics', kinds: ['chart'], outputs: both },
-    { id: 'trend', kinds: ['chart'], outputs: both }, { id: 'results', kinds: ['chart'], outputs: both },
-    { id: 'quotation', kinds: ['quote'], outputs: both }, { id: 'testimonial', kinds: ['quote'], outputs: both },
-    { id: 'code-example', kinds: ['code'], outputs: both }, { id: 'specifications', kinds: ['parameters'], outputs: both },
-    { id: 'pricing-details', kinds: ['parameters'], outputs: both }, { id: 'event-details', kinds: ['parameters'], outputs: both },
-    { id: 'recruitment-details', kinds: ['parameters'], outputs: both },
-    { id: 'product-demonstration', kinds: ['image'], outputs: both, requiresAsset: true },
-    { id: 'photograph', kinds: ['image'], outputs: both, requiresAsset: true },
-    ...['banner-hero', 'product-showcase', 'editorial-cover', 'image-campaign'].map(id => ({ id, kinds: ['image'], outputs: both, requiresAsset: true })),
+    { id: "menu-details", kinds: ["parameters"], outputs: both },
+    { id: "travel-details", kinds: ["parameters"], outputs: both },
+    { id: "offer-details", kinds: ["parameters"], outputs: both },
+    { id: "questions", kinds: ["features"], outputs: both },
+    { id: "case-study", kinds: ["features"], outputs: both },
+    { id: "brand-collection", kinds: ["features"], outputs: both },
+    { id: "hero", kinds: ["paragraph"], outputs: both },
+    { id: "chapter", kinds: ["paragraph"], outputs: ["presentation"] },
+    { id: "statement", kinds: ["paragraph"], outputs: both },
+    { id: "closing", kinds: ["paragraph"], outputs: both },
+    { id: "product-launch", kinds: ["features"], outputs: both },
+    { id: "feature-spotlight", kinds: ["features"], outputs: both },
+    { id: "feature-overview", kinds: ["features"], outputs: both },
+    { id: "benefits", kinds: ["features"], outputs: both },
+    { id: "comparison", kinds: ["comparison"], outputs: both },
+    { id: "before-after", kinds: ["comparison"], outputs: both },
+    { id: "plan-options", kinds: ["comparison"], outputs: both },
+    { id: "process", kinds: ["steps"], outputs: both },
+    { id: "roadmap", kinds: ["steps"], outputs: both },
+    { id: "tutorial", kinds: ["steps"], outputs: both },
+    { id: "checklist", kinds: ["features"], outputs: both },
+    { id: "metrics", kinds: ["chart"], outputs: both },
+    { id: "trend", kinds: ["chart"], outputs: both },
+    { id: "results", kinds: ["chart"], outputs: both },
+    { id: "quotation", kinds: ["quote"], outputs: both },
+    { id: "testimonial", kinds: ["quote"], outputs: both },
+    { id: "code-example", kinds: ["code"], outputs: both },
+    { id: "specifications", kinds: ["parameters"], outputs: both },
+    { id: "pricing-details", kinds: ["parameters"], outputs: both },
+    { id: "event-details", kinds: ["parameters"], outputs: both },
+    { id: "recruitment-details", kinds: ["parameters"], outputs: both },
+    {
+        id: "product-demonstration",
+        kinds: ["image"],
+        outputs: both,
+        requiresAsset: true,
+    },
+    { id: "photograph", kinds: ["image"], outputs: both, requiresAsset: true },
+    ...[
+        "banner-hero",
+        "product-showcase",
+        "editorial-cover",
+        "image-campaign",
+    ].map((id) => ({
+        id,
+        kinds: ["image"],
+        outputs: both,
+        requiresAsset: true,
+    })),
 ];
 export const AUTHORED_COMPOSITIONS = [
-    { id: 'feature-focus', kind: 'features', min: 1, max: 1 },
-    { id: 'feature-bento', kind: 'features', min: 2, max: 6 },
-    { id: 'feature-index', kind: 'features', min: 2, max: 6 },
-    { id: 'steps-journey', kind: 'steps', min: 2, max: 6 },
-    { id: 'steps-ribbon', kind: 'steps', min: 2, max: 4 },
-    { id: 'comparison-panels', kind: 'comparison', min: 2, max: 3 },
-    { id: 'quote-editorial', kind: 'quote', min: 0, max: 0 },
-    { id: 'quote-poster', kind: 'quote', min: 0, max: 0 },
-    { id: 'code-editorial', kind: 'code', min: 0, max: 0 },
-    { id: 'parameter-ledger', kind: 'parameters', min: 1, max: 8 },
-    { id: 'parameter-cards', kind: 'parameters', min: 1, max: 4 },
+    { id: "feature-focus", kind: "features", min: 1, max: 1 },
+    { id: "feature-bento", kind: "features", min: 2, max: 6 },
+    { id: "feature-index", kind: "features", min: 2, max: 6 },
+    { id: "steps-journey", kind: "steps", min: 2, max: 6 },
+    { id: "steps-ribbon", kind: "steps", min: 2, max: 4 },
+    { id: "comparison-panels", kind: "comparison", min: 2, max: 3 },
+    { id: "quote-editorial", kind: "quote", min: 0, max: 0 },
+    { id: "quote-poster", kind: "quote", min: 0, max: 0 },
+    { id: "code-editorial", kind: "code", min: 0, max: 0 },
+    { id: "parameter-ledger", kind: "parameters", min: 1, max: 8 },
+    { id: "parameter-cards", kind: "parameters", min: 1, max: 4 },
 ];
 /** Soft art-direction preferences; capacity and measured quality always remain mandatory. */
 export function sceneRecipePreference(scene, recipeId) {
     const preferred = {
-        'banner-hero': ['authored-image-banner'], 'product-showcase': ['authored-image-split'], 'editorial-cover': ['authored-image-editorial'], 'image-campaign': ['authored-image-campaign'],
-        hero: ['cover', 'semantic-hero-split'], chapter: ['section', 'semantic-hero-editorial'], statement: ['statement', 'semantic-hero-stack'], closing: ['closing'],
-        'product-launch': ['authored-feature-bento'], 'feature-spotlight': ['authored-feature-focus'], 'feature-overview': ['authored-feature-bento', 'three-column'], benefits: ['authored-feature-index'],
-        comparison: ['authored-comparison-panels'], 'before-after': ['before-after', 'semantic-comparison-split'], 'plan-options': ['authored-comparison-panels'],
-        process: ['authored-steps-ribbon'], roadmap: ['authored-steps-ribbon', 'roadmap'], tutorial: ['authored-steps-journey'], checklist: ['authored-feature-index', 'checklist'],
-        quotation: ['authored-quote-editorial'], testimonial: ['authored-quote-poster'],
-        'code-example': ['authored-code-editorial'], specifications: ['authored-parameter-ledger'],
-        'pricing-details': ['authored-parameter-cards'], 'event-details': ['authored-parameter-cards'], 'recruitment-details': ['authored-parameter-ledger'],
+        "banner-hero": ["authored-image-banner"],
+        "product-showcase": ["authored-image-split"],
+        "editorial-cover": ["authored-image-editorial"],
+        "image-campaign": ["authored-image-campaign"],
+        hero: ["cover", "semantic-hero-split"],
+        chapter: ["section", "semantic-hero-editorial"],
+        statement: ["statement", "semantic-hero-stack"],
+        closing: ["closing"],
+        "product-launch": ["authored-feature-bento"],
+        "feature-spotlight": ["authored-feature-focus"],
+        "feature-overview": ["authored-feature-bento", "three-column"],
+        benefits: ["authored-feature-index"],
+        comparison: ["authored-comparison-panels"],
+        "before-after": ["before-after", "semantic-comparison-split"],
+        "plan-options": ["authored-comparison-panels"],
+        process: ["authored-steps-ribbon"],
+        roadmap: ["authored-steps-ribbon", "roadmap"],
+        tutorial: ["authored-steps-journey"],
+        checklist: ["authored-feature-index", "checklist"],
+        quotation: ["authored-quote-editorial"],
+        testimonial: ["authored-quote-poster"],
+        "code-example": ["authored-code-editorial"],
+        specifications: ["authored-parameter-ledger"],
+        "pricing-details": ["authored-parameter-cards"],
+        "event-details": ["authored-parameter-cards"],
+        "recruitment-details": ["authored-parameter-ledger"],
     };
-    return scene && preferred[scene]?.some(id => recipeId === id || recipeId.startsWith(`${id}--`)) ? 6 : 0;
+    return scene &&
+        preferred[scene]?.some((id) => recipeId === id || recipeId.startsWith(`${id}--`))
+        ? 6
+        : 0;
 }

package/dist/compositionUseCases.d.ts

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