@neatico/visual-core 0.14.26 → 0.14.64

package/dist/formalCompositions.js

@@ -0,0 +1,116 @@
+import { compositionUseCase } from './compositionUseCases.js';
+import { nativeSocialParameterContract } from './nativeSocialParameters.js';
+import { DESIGN_RECIPES } from './designSystem.js';
+import { SOCIAL_LAYOUT_CATALOG } from './socialLayouts.js';
+import { recipeParameterContract } from './recipeParameters.js';
+import { SEMANTIC_DISPLAY_NUMBERS, SOCIAL_DISPLAY_NUMBERS } from './compositionNumbers.js';
+const both = ['presentation', 'social'];
+const semantic = (id, accepts, minEntries = 0, maxEntries = 12, requiresImage = false) => ({ id, renderer: 'semantic', kind: 'social', family: id, accepts, minEntries, maxEntries, requiresImage });
+function define(recipe, kinds, id, displayNumber, min = .25, max = 4) {
+    return { ...recipeParameterContract(recipe, kinds), semanticDescription: compositionUseCase(recipe.id), id, displayNumber, aspectRatios: { min, max }, recipe };
+}
+/** Structural reference contracts shared with the product's existing renderers.
+ * Colorways and historical aliases remain outside active discovery.
+ */
+export const FORMAL_REFERENCE_COMPOSITIONS = [
+    { id: 'authored-reference-photo', reference: 1, layout: 'authored-photo-editorial', accepts: ['image', 'paragraph'] },
+    { id: 'authored-reference-manifesto', reference: 2, layout: 'authored-type-manifesto', accepts: ['paragraph'] },
+    { id: 'authored-reference-journey', reference: 3, layout: 'authored-editorial-flow', accepts: ['steps'] },
+    { id: 'authored-reference-vision', reference: 4, layout: 'authored-editorial-features', accepts: ['features'] },
+    { id: 'authored-reference-matrix', reference: 5, layout: 'authored-editorial-matrix', accepts: ['comparison', 'paragraph'] },
+    { id: 'authored-reference-diagonal', reference: 6, layout: 'authored-diagonal-cover', accepts: ['paragraph'] },
+    { id: 'authored-reference-list', reference: 8, layout: 'authored-editorial-index', accepts: ['features'] },
+    { id: 'authored-reference-story', reference: 11, layout: 'authored-visual-poster', accepts: ['image', 'paragraph', 'features'] },
+    { id: 'authored-reference-sustainable', reference: 13, layout: 'authored-editorial-metrics', accepts: ['parameters'] },
+    { id: 'authored-reference-code', reference: 14, layout: 'authored-code-panel', accepts: ['code'] },
+    { id: 'authored-reference-bars', reference: 18, layout: 'authored-editorial-bars', accepts: ['chart'] },
+    { id: 'authored-reference-share', reference: 19, layout: 'authored-editorial-donut', accepts: ['chart'] },
+    { id: 'authored-reference-opinion', reference: 20, layout: 'authored-editorial-quote', accepts: ['quote'] },
+    { id: 'authored-reference-comparison', reference: 22, layout: 'authored-editorial-comparison', accepts: ['comparison'] },
+    { id: 'authored-reference-faq', reference: 23, layout: 'authored-editorial-faq', accepts: ['features'] },
+    { id: 'authored-reference-trend', reference: 25, layout: 'authored-editorial-trend', accepts: ['chart'] },
+];
+const semanticRecipes = DESIGN_RECIPES.filter(recipe => recipe.renderer === 'semantic');
+const uniqueSemantic = semanticRecipes.filter((recipe, index) => semanticRecipes.findIndex(other => other.id === recipe.id) === index);
+const campaignDefinitions = [
+    ['ledger-chart', ['parameters', 'chart'], 2, 6, false, true],
+    ['detail-sidebar', ['paragraph', 'parameters'], 1, 3, false, true],
+    ['technical-log', ['code', 'paragraph'], 0, 12, false, false],
+    ['architecture-stack', ['steps', 'paragraph'], 2, 4, false, false],
+    ['speaker-spotlight', ['quote', 'parameters'], 1, 6, true, false],
+    ['speaker-lineup', ['quote', 'parameters'], 1, 6, true, false],
+];
+const founderDefinitions = [
+    ['authored-mechanism-flow', ['features', 'steps', 'paragraph'], 2, 4],
+    ['authored-reference-capability-map', ['features', 'paragraph'], 2, 4],
+    ['authored-founder-timeline', ['steps', 'paragraph'], 2, 4],
+    ['authored-founder-comparison', ['comparison', 'paragraph'], 2, 2],
+];
+const articleKinds = ['features', 'process', 'comparison', 'summary', 'checklist', 'faq', 'chart'];
+const articleAccepts = { features: ['features', 'paragraph'], process: ['steps', 'paragraph'], comparison: ['comparison', 'paragraph'], summary: ['paragraph', 'features'], checklist: ['features', 'paragraph'], faq: ['features', 'paragraph'], chart: ['chart', 'paragraph'] };
+function article(id, kind, variant) {
+    const cover = kind === 'cover';
+    const recipe = semantic(id, cover ? ['paragraph', 'features', 'image'] : articleAccepts[kind], 0, kind === 'chart' ? 12 : 3);
+    const number = cover ? variant + 1 : kind === 'features' && variant >= 3 ? 22 + variant : kind === 'process' && variant === 3 ? 33 : 4 + articleKinds.indexOf(kind) * 3 + variant;
+    const definition = define(recipe, [cover ? 'article-cover' : 'article-illustration'], id, `A${String(number).padStart(3, '0')}`, .5, 2.4);
+    // A cover is a headline, a short deck and its authored hero. It is not a
+    // miniature article: the original source remains in the candidate pool.
+    const coverSchema = { type: 'object', additionalProperties: false, required: ['title', 'blocks'], properties: {
+            title: { type: 'string', minLength: 1, maxLength: 72, description: 'A concise editorial headline, preferably four to eight words.' },
+            blocks: { type: 'array', minItems: 1, maxItems: 1, items: { type: 'object', additionalProperties: false, required: ['id', 'kind', 'text', 'evidence'], properties: {
+                        id: { type: 'string', minLength: 1, maxLength: 80 }, kind: { const: 'paragraph' }, text: { type: 'string', minLength: 1, maxLength: 140, description: 'One concise supporting sentence. Summarize the topic; do not repeat the full article or enumerate every feature.' },
+                        evidence: { type: 'array', minItems: 1, maxItems: 32, items: { type: 'object', additionalProperties: false, required: ['sourceId'], properties: { sourceId: { type: 'string', maxLength: 160 }, quote: { type: 'string', maxLength: 2000 } } } },
+                    } } },
+        } };
+    // The optional hero preserves compatibility with saved paragraph-only pools.
+    // New requests can reference a real asset; missing assets retain native artwork.
+    const coverWithHero = { ...coverSchema, properties: { ...coverSchema.properties, blocks: { ...coverSchema.properties.blocks, maxItems: 2,
+                description: 'One supporting paragraph and, when imagery helps explain the topic, one image hero. Use an available asset ID or a missing image request; never invent a photo URL.',
+                items: [coverSchema.properties.blocks.items, { type: 'object', additionalProperties: false, required: ['id', 'kind', 'sourceId', 'alt', 'treatment', 'status', 'evidence'], properties: {
+                            id: { type: 'string', minLength: 1, maxLength: 80 }, kind: { const: 'image' }, sourceId: { type: 'string', maxLength: 160 },
+                            alt: { type: 'string', minLength: 1, maxLength: 300, description: 'A concise description of the image subject, grounded in the article topic.' },
+                            treatment: { enum: ['photograph', 'diagram', 'screenshot'] }, status: { enum: ['available', 'missing'] }, assetId: { type: 'string', maxLength: 200 },
+                            evidence: coverSchema.properties.blocks.items.properties.evidence,
+                        } }],
+            } } };
+    const illustrationSchema = JSON.parse(JSON.stringify(definition.parameterSchema));
+    if (!cover) {
+        const primaryKind = kind === 'summary' ? 'features' : articleAccepts[kind][0];
+        const blocks = illustrationSchema.properties.blocks;
+        const primary = blocks.items.find((block) => block.properties.kind.const === primaryKind);
+        blocks.items = [primary];
+        blocks.minItems = 1;
+        blocks.maxItems = 1;
+        if (kind === 'faq')
+            primary.properties.entries.items.properties.title.pattern = '^.+[?？]$';
+    }
+    const coverDirections = ['An editorial document sculpture with layered planes and a strong headline.', 'A connected constellation with a single focal object and an editorial headline.', 'An architectural archive silhouette balanced against expressive editorial typography.'];
+    return { ...definition, ...(cover ? { parameterSchema: coverWithHero, capacity: { minEntries: 0, maxEntries: 0, requiresImage: false }, semanticDescription: coverDirections[variant] } : { parameterSchema: illustrationSchema }), recipe: undefined, rendererKey: `article-${kind}:${variant}`,
+        semanticDescription: compositionUseCase(id) + (cover ? ' ' + coverDirections[variant] : '') };
+}
+/** Matches /dev/compositions/all: 161 default previews plus two landscape-only
+ * reference entries. Output capabilities overlap and must never be summed.
+ */
+export const FORMAL_COMPOSITIONS = [
+    ...campaignDefinitions.map(([id, accepts, min, max, image, landscape], index) => define(semantic(`authored-reference-${id}`, accepts, min, max, image), landscape ? ['presentation'] : both, `new-reference:${id}`, `N${index + 1}`, landscape ? 1.4 : .25)),
+    define(semantic('authored-event-poster', ['parameters', 'paragraph'], 1, 6), ['social'], 'event:provider', 'E1'),
+    define(semantic('authored-image-triptych', ['paragraph', 'features', 'image'], 3, 3, true), ['social'], 'campaign:triptych', 'C1', .5, 2),
+    ...FORMAL_REFERENCE_COMPOSITIONS.map(spec => define(semantic(spec.id, spec.accepts, 0, 12, spec.accepts.includes('image')), both, `reference:${spec.id}`, `R${String(spec.reference).padStart(2, '0')}`)),
+    ...SOCIAL_LAYOUT_CATALOG.map(preset => {
+        const recipe = DESIGN_RECIPES.find(item => item.id === preset.id && item.kind === 'social');
+        return { ...define({ ...recipe, renderer: 'catalog' }, ['social'], `social:${preset.id}`, SOCIAL_DISPLAY_NUMBERS[preset.id], .5, 2.4), ...nativeSocialParameterContract(preset.id) };
+    }),
+    ...uniqueSemantic.map(recipe => define(recipe, semanticRecipes.filter(other => other.id === recipe.id).map(other => other.kind), `semantic:${recipe.kind}:${recipe.id}`, SEMANTIC_DISPLAY_NUMBERS[`semantic:${recipe.kind}:${recipe.id}`])),
+    ...founderDefinitions.map(([id, accepts, min, max], index) => define(semantic(id, accepts, min, max), ['social'], `semantic:social:${id}`, `F${index + 1}`, 1.3)),
+    ...[0, 1, 2].flatMap(variant => [article(`article-cover-${variant}`, 'cover', variant), ...articleKinds.map(kind => article(`article-${kind}-${variant}`, kind, variant))]),
+    ...[3, 4, 5, 6, 7, 8, 9, 10].map(variant => article(`article-features-${variant}`, 'features', variant)),
+    article('article-process-3', 'process', 3),
+];
+/** Only output, ratio, and explicit IDs are hard gates; semantic fit is scored. */
+export function applicableCompositions(kind, ratio, id) {
+    if (!Number.isFinite(ratio) || ratio <= 0)
+        throw new Error('COMPOSITION_INVALID_RATIO');
+    if (id && !FORMAL_COMPOSITIONS.some(item => item.id === id))
+        throw new Error('COMPOSITION_UNKNOWN_ID');
+    return FORMAL_COMPOSITIONS.filter(item => item.supportedKinds.includes(kind) && ratio >= item.aspectRatios.min && ratio <= item.aspectRatios.max && (!id || item.id === id));
+}

package/dist/index.d.ts

@@ -13,3 +13,13 @@ export * from "./designBlueprint.js";
 export * from './compositionScenes.js';
 export * from './editorial.js';
 export * from './fontCatalog.js';
+export * from './candidateRanking.js';
+export * from './styleManifest.js';
+export * from './recipeParameters.js';
+export * from './formalCompositions.js';
+export * from './contentBrief.js';
+export * from "./nativeSocialParameters.js";
+export * from "./compositionUseCases.js";
+export { compositionParameterDefaults } from './parameterDefaults.js';
+export { SOCIAL_DISPLAY_NUMBERS } from './compositionNumbers.js';
+export * from './textPresentation.js';

package/dist/index.js

@@ -13,3 +13,13 @@ export * from "./designBlueprint.js";
 export * from './compositionScenes.js';
 export * from './editorial.js';
 export * from './fontCatalog.js';
+export * from './candidateRanking.js';
+export * from './styleManifest.js';
+export * from './recipeParameters.js';
+export * from './formalCompositions.js';
+export * from './contentBrief.js';
+export * from "./nativeSocialParameters.js";
+export * from "./compositionUseCases.js";
+export { compositionParameterDefaults } from './parameterDefaults.js';
+export { SOCIAL_DISPLAY_NUMBERS } from './compositionNumbers.js';
+export * from './textPresentation.js';

package/dist/nativeSocialParameters.d.ts

@@ -0,0 +1,38 @@
+import { type TextPresentation } from './textPresentation.js';
+import type { ParameterSchema } from './recipeParameters.js';
+/** Native slots keep renderer-specific content separate from semantic page projection. */
+export interface NativeSocialParameters {
+    textPresentation?: TextPresentation[];
+    decorationEmoji?: string;
+    title: string;
+    body: string;
+    eyebrow?: string;
+    emphasis?: string[];
+    titleLines?: string[];
+    cta?: string;
+    value?: string;
+    attribution?: string;
+    imageAssetId?: string;
+    comparisonLabels?: [string, string];
+    items?: {
+        title: string;
+        description: string;
+        assetId?: string;
+        illustration?: 'document' | 'collaboration' | 'review' | 'feedback' | 'sequence' | 'comparison' | 'structure';
+        primaryValue?: number;
+        secondaryValue?: number;
+    }[];
+}
+export interface NativeSocialContract {
+    parameterModel: 'native-social';
+    parameterSchema: ParameterSchema;
+    importance: Readonly<Record<string, number>>;
+    generationPolicy: Readonly<Record<string, readonly string[]>>;
+}
+export declare const COMPOSITION_ILLUSTRATIONS: readonly ["document", "collaboration", "review", "feedback", "sequence", "comparison", "structure"];
+/** Every field corresponds to an authored visible slot; no scene-based eligibility filter. */
+export declare function nativeSocialParameterContract(id: string): NativeSocialContract;
+/** Apply the small closed schema vocabulary used by native slots on every local render. */
+export declare function validateNativeSocialParameters(id: string, raw: unknown): NativeSocialParameters;
+/** Numeric and image identities remain available when a native design becomes editable content. */
+export declare function nativeSocialContentPage(values: NativeSocialParameters, original: import('./content.js').ContentPage): import('./content.js').ContentPage;

package/dist/nativeSocialParameters.js

@@ -0,0 +1,139 @@
+import { compositionParameterDefaults } from './parameterDefaults.js';
+import { textPresentationSchema, validateTextPresentations } from './textPresentation.js';
+import { SOCIAL_LAYOUT_CATALOG } from './socialLayouts.js';
+const slots = {
+    'note-question': {}, 'note-marker': {}, 'note-editorial': {}, 'note-checklist': { items: 3 }, 'note-photo': { image: true }, 'note-news': { value: true },
+    'chat-messenger': { items: 3 }, 'chat-imessage': { items: 3 }, 'chat-telegram': { items: 3 }, 'chat-workplace': { items: 3 },
+    'time-notice': { value: true }, 'news-focus': {}, manifesto: {}, launch: { image: true }, bento: { items: 3 }, spotlight: { items: 3, value: true, image: true },
+    ticket: { items: 2, value: true }, webinar: { value: true, image: true }, quote: { attribution: true }, testimonial: { attribution: true }, metric: { value: true },
+    report: { items: 3 }, checklist: { items: 3 }, steps: { items: 3 }, comparison: { items: 2 }, myth: { items: 2 }, pricing: { items: 3, value: true }, offer: { value: true, image: true },
+    editorial: { image: true }, story: { image: true }, hiring: { items: 3 }, team: { items: 3, itemImages: true }, course: { items: 3 }, 'case-study': { items: 3 }, notice: {}, community: { value: true },
+    menu: { items: 3 }, specification: { items: 3 }, itinerary: { items: 3 }, schedule: { items: 3 }, safety: { items: 3 }, faq: { items: 3 },
+    'split-bar-compare': { items: 3, quantities: 'comparison' }, 'benchmark-bars': { items: 3, quantities: 'benchmark' }, 'usage-breakdown': { items: 3, quantities: 'share' },
+    organization: { items: 3 }, 'editorial-quote': { attribution: true }, 'research-highlight': { items: 2 }, 'product-showcase': { items: 3, image: true },
+};
+const copy = (maxLength, description, minLength = 1) => ({ type: 'string', minLength, maxLength, description });
+const object = (properties) => ({ type: 'object', additionalProperties: false, properties, required: Object.keys(properties) });
+const asset = () => copy(160, 'An existing supplied asset ID. Use neatico-editorial-placeholder when no matching source image exists.');
+export const COMPOSITION_ILLUSTRATIONS = ['document', 'collaboration', 'review', 'feedback', 'sequence', 'comparison', 'structure'];
+const illustratedSlots = new Set(['bento', 'course', 'case-study', 'report', 'product-showcase', 'comparison', 'research-highlight']);
+const provenance = ['user-fact', 'derived', 'creative', 'simulated'];
+// These authored slots have been measured with complete provider sentences at
+// square, landscape, and portrait ratios. Compact labels keep their own limits.
+const sentenceBodySlots = new Set(['note-question', 'note-marker', 'note-editorial', 'chat-imessage', 'chat-telegram', 'news-focus', 'manifesto', 'launch', 'spotlight', 'comparison', 'myth', 'editorial', 'story', 'notice']);
+const supportingItemSlots = new Set(['team', 'course', 'specification', 'schedule', 'research-highlight']);
+/** Every field corresponds to an authored visible slot; no scene-based eligibility filter. */
+export function nativeSocialParameterContract(id) {
+    const spec = slots[id];
+    if (!spec || !SOCIAL_LAYOUT_CATALOG.some(item => item.id === id))
+        throw new Error('COMPOSITION_UNKNOWN_NATIVE_SOCIAL');
+    const properties = { title: copy(id === 'note-question' ? 44 : 40, 'Concise audience-facing headline.'), body: copy(id === 'organization' ? 32 : id === 'case-study' ? 64 : ['quote', 'testimonial', 'editorial-quote'].includes(id) ? 140 : sentenceBodySlots.has(id) ? 96 : 80, id === 'organization' ? 'A short label for the parent or coordinating role; never invent a real person.' : 'One supporting sentence, or the quoted passage for a quote composition.') };
+    if (!id.startsWith('chat-') && !['note-photo', 'note-checklist'].includes(id))
+        properties.eyebrow = { ...copy(20, 'Optional concise section label. Use an empty string when no label improves the message.', 0), default: '' };
+    if (!id.startsWith('chat-') && !['note-photo', 'note-checklist'].includes(id))
+        properties.cta = { ...copy(24, 'Optional short call to action appropriate to the input. Use an empty string when this is purely informational.', 0), default: '' };
+    if (['note-marker', 'note-editorial', 'note-question'].includes(id))
+        properties.titleLines = { type: 'array', minItems: 0, maxItems: 4, default: [], items: copy(40, 'One complete phrase from the title, preserving its original language.'), description: 'Preferred title lines: one item for a single line, two to four for a multiline heading, or empty for automatic fitting. Concatenating the phrases must preserve the complete title and word boundaries. The renderer may reflow only when the requested lines cannot fit legibly.' };
+    if (id === 'note-marker')
+        properties.emphasis = { type: 'array', minItems: 0, maxItems: 2, default: [], items: copy(40, 'An exact contiguous phrase from title to highlight.'), description: 'Choose one or two important exact title phrases. Empty means the renderer highlights the final title line.' };
+    if (spec.value)
+        properties.value = copy(24, 'The focal quantity, price, time, or short value statement. Label fictional quantities as simulated.');
+    if (spec.attribution)
+        properties.attribution = copy(48, 'Exact supplied attribution, or an empty string. Never invent an endorsement.', 0);
+    if (spec.image)
+        properties.imageAssetId = asset();
+    if (spec.items) {
+        const item = { title: copy(id === 'faq' ? 40 : id === 'case-study' ? 18 : 20, id === 'faq' ? 'A concise audience question ending in a question mark.' : 'A short item label.'), description: copy(id === 'faq' ? 64 : spec.quantities || id === 'case-study' ? 32 : ['comparison', 'myth'].includes(id) ? 80 : supportingItemSlots.has(id) ? 48 : 40, 'Concise supporting copy.', spec.quantities ? 0 : 1) };
+        if (id === 'faq')
+            item.title.pattern = '^.+[?？]$';
+        if (illustratedSlots.has(id))
+            item.illustration = { type: 'string', enum: COMPOSITION_ILLUSTRATIONS, default: 'structure', description: 'An editable native illustration that explains this item. Choose document for material, review for checking, collaboration for people, feedback for revision, sequence for ordered actions, comparison for alternatives, or structure for organization. Never omit the visual slot.' };
+        if (spec.itemImages)
+            item.assetId = asset();
+        if (spec.quantities) {
+            item.primaryValue = { type: 'number', minimum: 0, maximum: 100, description: spec.quantities === 'comparison' ? 'A percentage from zero to one hundred. primaryValue plus secondaryValue must equal exactly 100 in this item.' : 'A percentage from zero to one hundred. Never encode numbers inside descriptive copy.' };
+            if (spec.quantities !== 'share')
+                item.secondaryValue = { type: 'number', minimum: 0, maximum: 100, description: 'The comparison or benchmark percentage.' };
+            if (spec.quantities === 'share')
+                item.description = { const: '' };
+        }
+        properties.items = { type: 'array', minItems: spec.items, maxItems: spec.items, items: object(item), ...(spec.quantities === 'share' ? { description: 'Exactly three nonnegative percentage shares totaling at most one hundred.' } : {}) };
+    }
+    if (spec.quantities === 'comparison' || spec.quantities === 'benchmark')
+        properties.comparisonLabels = { type: 'array', minItems: 2, maxItems: 2, items: copy(20, 'A supplied or explicitly illustrative series label.') };
+    if (['note-question', 'note-marker', 'note-editorial'].includes(id))
+        properties.decorationEmoji = { type: 'string', enum: ['', '✨', '💡', '🌱', '💬', '🎯', '📚'], default: '', description: 'Optional built-in decorative emoji for informal social notes. Choose one relevant symbol, or empty for the authored illustration. Never use it as factual evidence.' };
+    properties.textPresentation = textPresentationSchema();
+    const contentKeys = Object.keys(properties).filter(key => !['textPresentation', 'decorationEmoji'].includes(key));
+    const importance = Object.fromEntries(contentKeys.map(key => [key, key === 'title' ? 3 : key === 'items' ? 7 : ['eyebrow', 'cta'].includes(key) ? .5 : 2]));
+    return { parameterModel: 'native-social', parameterSchema: object(properties), importance, generationPolicy: Object.fromEntries(contentKeys.map(key => [key, provenance])) };
+}
+/** Apply the small closed schema vocabulary used by native slots on every local render. */
+export function validateNativeSocialParameters(id, raw) {
+    const check = (value, schema) => {
+        if (Object.hasOwn(schema, 'const'))
+            return value === schema.const;
+        if (Array.isArray(schema.enum))
+            return schema.enum.includes(value);
+        if (schema.type === 'string')
+            return typeof value === 'string' && Array.from(value).length >= Number(schema.minLength || 0) && Array.from(value).length <= Number(schema.maxLength) && (!schema.pattern || new RegExp(String(schema.pattern), 'u').test(value));
+        if (schema.type === 'boolean')
+            return typeof value === 'boolean';
+        if (schema.type === 'number')
+            return typeof value === 'number' && Number.isFinite(value) && value >= Number(schema.minimum) && value <= Number(schema.maximum);
+        if (schema.type === 'array')
+            return Array.isArray(value) && value.length >= Number(schema.minItems) && value.length <= Number(schema.maxItems) && value.every(item => check(item, schema.items));
+        if (schema.type === 'object') {
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                return false;
+            const properties = schema.properties, object = value;
+            return Object.keys(object).every(key => Object.hasOwn(properties, key) && check(object[key], properties[key])) && schema.required.every(key => Object.hasOwn(object, key) && check(object[key], properties[key]));
+        }
+        return false;
+    };
+    const schema = nativeSocialParameterContract(id).parameterSchema;
+    raw = compositionParameterDefaults(schema, raw);
+    if (!check(raw, schema))
+        throw new Error('CANDIDATE_INVALID_PARAMETERS');
+    const values = raw;
+    validateTextPresentations(values.textPresentation, values);
+    if (values.titleLines?.length) {
+        const normalize = (copy) => copy.normalize('NFC').replace(/\s+/gu, ' ').trim();
+        const title = normalize(values.title);
+        let cursor = 0;
+        for (const phrase of values.titleLines) {
+            const line = normalize(phrase), hadSpace = title[cursor] === ' ';
+            if (hadSpace)
+                cursor++;
+            // CJK phrases may meet without spaces, but Latin words cannot be split.
+            const brokenWord = cursor > 0 && !hadSpace && /[\p{Script=Latin}\p{Mark}\d’'-]/u.test(title[cursor - 1]) && /^[\p{Script=Latin}\p{Mark}\d’'-]/u.test(line);
+            if (!line || brokenWord || !title.startsWith(line, cursor))
+                throw new Error('CANDIDATE_INVALID_TITLE_LINES');
+            cursor += line.length;
+        }
+        if (cursor !== title.length)
+            throw new Error('CANDIDATE_INVALID_TITLE_LINES');
+    }
+    if (values.emphasis?.some(phrase => !values.title.includes(phrase)))
+        throw new Error('CANDIDATE_INVALID_EMPHASIS');
+    if (id === 'usage-breakdown' && values.items.reduce((sum, item) => sum + item.primaryValue, 0) > 100.0001)
+        throw new Error('CANDIDATE_INVALID_PERCENTAGES');
+    if (id === 'split-bar-compare' && values.items.some(item => Math.abs(item.primaryValue + item.secondaryValue - 100) > .001))
+        throw new Error('CANDIDATE_INVALID_PERCENTAGES');
+    return JSON.parse(JSON.stringify(values));
+}
+/** Numeric and image identities remain available when a native design becomes editable content. */
+export function nativeSocialContentPage(values, original) {
+    const proof = original.evidence, blocks = [{ id: 'native-body', kind: 'paragraph', text: values.body, evidence: proof }];
+    if (values.items?.length)
+        blocks.push({ id: 'native-items', kind: 'features', evidence: proof, entries: values.items.map(item => ({ title: item.title, ...(item.illustration ? { illustration: item.illustration } : {}), description: [item.description, ...[item.primaryValue, item.secondaryValue].filter(value => value !== undefined).map(value => `${value}%`)].filter(Boolean).join(' · ') })) });
+    for (const field of ['value', 'attribution', 'eyebrow', 'cta'])
+        if (values[field])
+            blocks.push({ id: `native-${field}`, kind: 'paragraph', text: values[field], evidence: proof });
+    if (values.comparisonLabels)
+        blocks.push({ id: 'native-series', kind: 'paragraph', evidence: proof, text: values.comparisonLabels.join(' / ') });
+    const images = [values.imageAssetId, ...(values.items || []).map(item => item.assetId)].filter((id) => !!id);
+    for (const [index, assetId] of images.entries())
+        blocks.push({ id: `native-image-${index}`, kind: 'image', evidence: [{ sourceId: assetId }], sourceId: assetId, assetId, alt: values.title, treatment: assetId === 'neatico-editorial-placeholder' ? 'diagram' : 'photograph', status: 'available' });
+    return { ...original, title: values.title, blocks };
+}

package/dist/pagination.js

@@ -1,12 +1,21 @@
 /** Split only at explicit word/sentence boundaries. Never cut identifiers,
  * decimal values, or unbroken URLs to force them onto a smaller canvas. */
 export function splitCopy(copy) {
-    const breaks = [...copy.matchAll(/\s+|[。！？；]|[.!?;](?=\s|$)/gu)]
-        .map((match) => match.index + match[0].length)
-        .filter((index) => index > 0 && index < copy.length);
-    if (!breaks.length)
+    let at;
+    let distance = Infinity;
+    const midpoint = copy.length / 2;
+    for (const match of copy.matchAll(/\s+|[。！？；]|[.!?;](?=\s|$)/gu)) {
+        const index = match.index + match[0].length;
+        if (index <= 0 || index >= copy.length)
+            continue;
+        const candidateDistance = Math.abs(index - midpoint);
+        if (candidateDistance < distance) {
+            at = index;
+            distance = candidateDistance;
+        }
+    }
+    if (at === undefined)
         return;
-    const at = breaks.sort((a, b) => Math.abs(a - copy.length / 2) - Math.abs(b - copy.length / 2))[0];
     return [copy.slice(0, at), copy.slice(at)];
 }
 /** No paraphrasing, invented continuation labels or removed constraints. The

package/dist/parameterDefaults.d.ts

@@ -0,0 +1,2 @@
+/** Apply only renderer-authored defaults. Never rewrite supplied copy or values. */
+export declare function compositionParameterDefaults(schema: Readonly<Record<string, unknown>>, value: unknown): unknown;

package/dist/parameterDefaults.js

@@ -0,0 +1,17 @@
+/** Apply only renderer-authored defaults. Never rewrite supplied copy or values. */
+export function compositionParameterDefaults(schema, value) {
+    if (value === undefined && Object.hasOwn(schema, 'default'))
+        return JSON.parse(JSON.stringify(schema.default));
+    if (schema.type === 'object' && value && typeof value === 'object' && !Array.isArray(value)) {
+        const next = { ...value };
+        for (const [key, child] of Object.entries(schema.properties || {})) {
+            const resolved = compositionParameterDefaults(child, next[key]);
+            if (resolved !== undefined)
+                next[key] = resolved;
+        }
+        return next;
+    }
+    if (schema.type === 'array' && Array.isArray(value))
+        return value.map((item, index) => compositionParameterDefaults((Array.isArray(schema.items) ? schema.items[index] : schema.items) || {}, item));
+    return value;
+}

package/dist/recipeParameters.d.ts

@@ -0,0 +1,34 @@
+import { type DesignRecipe } from "./designSystem.js";
+export type ParameterSchema = Readonly<Record<string, unknown>>;
+export type CompositionKind = "presentation" | "social" | "article-cover" | "article-illustration";
+export interface RecipeParameterContract {
+    parameterModel?: "semantic" | "native-social";
+    id: string;
+    schemaVersion: 1;
+    supportedKinds: readonly CompositionKind[];
+    semanticDescription: string;
+    scenes: readonly string[];
+    rendererKey: string;
+    capacity: {
+        minEntries: number;
+        maxEntries: number;
+        requiresImage: boolean;
+    };
+    parameterSchema: ParameterSchema;
+    importance: Readonly<Record<string, number>>;
+    generationPolicy: Readonly<Record<string, readonly string[]>>;
+    themeBindings: readonly string[];
+    fallbackPolicy: {
+        missingContent: "derive-or-labeled-example";
+        missingAsset: "search-or-native-placeholder";
+        omitCandidate: false;
+    };
+}
+/** Fixed renderer parameters, not executable layout trees. The complete schema
+ * travels with each formal generation batch; summaries are scheduling aids only.
+ */
+export declare function recipeParameterContract(recipe: DesignRecipe, supportedKinds?: RecipeParameterContract["supportedKinds"]): RecipeParameterContract;
+/** Shared recipes are one part of the formal catalog; host-specific renderer
+ * definitions register through the same contract constructor during migration.
+ */
+export declare const RECIPE_PARAMETER_CONTRACTS: readonly RecipeParameterContract[];