@neatico/visual-core 0.14.26 → 0.14.64

package/dist/cjs/designSystem.js

@@ -14,9 +14,81 @@ exports.DESIGN_THEMES = [
     {
         id: "neatico",
         palette: { background: "#FAF9F6", surface: "#FFFFFF", ink: "#202124", muted: "#62646B", accent: "#F4CE36", line: "#E4E1D9" },
-        typography: { heading: "Inter", body: "Inter", code: "monospace", headingWeight: 700 },
+        typography: { heading: "Manrope", body: "Inter", code: "monospace", headingWeight: 700 },
         geometry: { radius: 12, spacing: 1, rule: "accent" },
     },
+    {
+        id: "archive",
+        palette: { background: "#F6F1E7", surface: "#FFFCF5", ink: "#19382E", muted: "#59665B", accent: "#C17A35", line: "#D7CEBC" },
+        typography: { heading: "Instrument Serif", body: "DM Sans", code: "JetBrains Mono", headingWeight: 400 },
+        geometry: { radius: 4, spacing: 1.1, rule: "hairline" },
+    },
+    {
+        "id": "bloom",
+        "palette": {
+            "background": "#FFF1F6",
+            "surface": "#FFFFFF",
+            "ink": "#341838",
+            "muted": "#70536D",
+            "accent": "#CC1D61",
+            "line": "#F3BED5"
+        },
+        "typography": {
+            "heading": "Montserrat",
+            "body": "Nunito Sans",
+            "code": "JetBrains Mono",
+            "headingWeight": 800
+        },
+        "geometry": {
+            "radius": 20,
+            "spacing": 1,
+            "rule": "accent"
+        }
+    },
+    {
+        "id": "splash",
+        "palette": {
+            "background": "#E9FAFF",
+            "surface": "#FFFFFF",
+            "ink": "#162E60",
+            "muted": "#4D637E",
+            "accent": "#2454E6",
+            "line": "#B8DEFA"
+        },
+        "typography": {
+            "heading": "Space Grotesk",
+            "body": "DM Sans",
+            "code": "JetBrains Mono",
+            "headingWeight": 700
+        },
+        "geometry": {
+            "radius": 20,
+            "spacing": 1,
+            "rule": "accent"
+        }
+    },
+    {
+        "id": "candy",
+        "palette": {
+            "background": "#F3EDFF",
+            "surface": "#FFFFFF",
+            "ink": "#35205C",
+            "muted": "#69557F",
+            "accent": "#7841D5",
+            "line": "#DCCAF6"
+        },
+        "typography": {
+            "heading": "Manrope",
+            "body": "Nunito Sans",
+            "code": "JetBrains Mono",
+            "headingWeight": 800
+        },
+        "geometry": {
+            "radius": 20,
+            "spacing": 1,
+            "rule": "accent"
+        }
+    },
     {
         id: "studio",
         palette: {
@@ -28,8 +100,8 @@ exports.DESIGN_THEMES = [
             line: "#D7DED3",
         },
         typography: {
-            heading: "Inter",
-            body: "Inter",
+            heading: "DM Sans",
+            body: "Source Sans 3",
             code: "monospace",
             headingWeight: 700,
         },
@@ -46,7 +118,7 @@ exports.DESIGN_THEMES = [
             line: "#3D526C",
         },
         typography: {
-            heading: "Inter",
+            heading: "Space Grotesk",
             body: "Inter",
             code: "monospace",
             headingWeight: 700,
@@ -65,7 +137,7 @@ exports.DESIGN_THEMES = [
         },
         typography: {
             heading: "Lora",
-            body: "Inter",
+            body: "Source Sans 3",
             code: "monospace",
             headingWeight: 700,
         },
@@ -82,8 +154,8 @@ exports.DESIGN_THEMES = [
             line: "#DAD5F2",
         },
         typography: {
-            heading: "Inter",
-            body: "Inter",
+            heading: "Space Grotesk",
+            body: "DM Sans",
             code: "monospace",
             headingWeight: 800,
         },
@@ -100,7 +172,7 @@ exports.DESIGN_THEMES = [
             line: "#B8A233",
         },
         typography: {
-            heading: "Inter",
+            heading: "Oswald",
             body: "Inter",
             code: "monospace",
             headingWeight: 800,

package/dist/cjs/fontCatalog.js

@@ -28,6 +28,7 @@ exports.GOOGLE_FONT_CATALOG = [
         "Playfair Display",
         "PT Serif",
     ].map((f) => entry(f, "serif")),
+    entry("Instrument Serif", "serif", ["latin"], [400]),
     ...["Space Grotesk", "Oswald", "Bebas Neue"].map((f) => entry(f, "display", ["latin"], f === "Bebas Neue" ? [400] : [400, 700])),
     ...["JetBrains Mono", "IBM Plex Mono", "Fira Code", "Source Code Pro"].map((f) => entry(f, "mono")),
     entry("Noto Sans SC", "sans", ["zh"]),
@@ -43,6 +44,9 @@ exports.GOOGLE_FONT_CATALOG = [
     entry("Noto Serif KR", "serif", ["ko"]),
     entry("Noto Sans Arabic", "sans", ["ar"]),
     entry("Noto Sans Devanagari", "sans", ["hi"]),
+    entry("Noto Serif Devanagari", "serif", ["hi"]),
+    entry("Noto Sans Thai", "sans", ["th"]),
+    entry("Noto Serif Thai", "serif", ["th"]),
 ];
 function contentScript(text, locale = "en") {
     if (/[\u3040-\u30ff]/u.test(text))
@@ -53,6 +57,8 @@ function contentScript(text, locale = "en") {
         return "ar";
     if (/[\u0900-\u097f]/u.test(text))
         return "hi";
+    if (/[\u0e00-\u0e7f]/u.test(text))
+        return "th";
     if (/[\u3400-\u9fff]/u.test(text))
         return /^ja/i.test(locale)
             ? "ja"
@@ -63,7 +69,7 @@ function contentScript(text, locale = "en") {
                     : "zh";
     if (/^zh/i.test(locale))
         return /TW|HK|Hant/i.test(locale) ? "zh-Hant" : "zh";
-    return /^(ja|ko|ar|hi)/.exec(locale)?.[1] || "latin";
+    return /^(ja|ko|ar|hi|th)/.exec(locale)?.[1] || "latin";
 }
 function recommendedFonts(locale, text = "") {
     const script = contentScript(text, locale);

package/dist/cjs/formalCompositions.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAL_COMPOSITIONS = exports.FORMAL_REFERENCE_COMPOSITIONS = void 0;
+exports.applicableCompositions = applicableCompositions;
+const compositionUseCases_js_1 = require("./compositionUseCases.js");
+const nativeSocialParameters_js_1 = require("./nativeSocialParameters.js");
+const designSystem_js_1 = require("./designSystem.js");
+const socialLayouts_js_1 = require("./socialLayouts.js");
+const recipeParameters_js_1 = require("./recipeParameters.js");
+const compositionNumbers_js_1 = require("./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 { ...(0, recipeParameters_js_1.recipeParameterContract)(recipe, kinds), semanticDescription: (0, compositionUseCases_js_1.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.
+ */
+exports.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 = designSystem_js_1.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: (0, compositionUseCases_js_1.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.
+ */
+exports.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),
+    ...exports.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')}`)),
+    ...socialLayouts_js_1.SOCIAL_LAYOUT_CATALOG.map(preset => {
+        const recipe = designSystem_js_1.DESIGN_RECIPES.find(item => item.id === preset.id && item.kind === 'social');
+        return { ...define({ ...recipe, renderer: 'catalog' }, ['social'], `social:${preset.id}`, compositionNumbers_js_1.SOCIAL_DISPLAY_NUMBERS[preset.id], .5, 2.4), ...(0, nativeSocialParameters_js_1.nativeSocialParameterContract)(preset.id) };
+    }),
+    ...uniqueSemantic.map(recipe => define(recipe, semanticRecipes.filter(other => other.id === recipe.id).map(other => other.kind), `semantic:${recipe.kind}:${recipe.id}`, compositionNumbers_js_1.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. */
+function applicableCompositions(kind, ratio, id) {
+    if (!Number.isFinite(ratio) || ratio <= 0)
+        throw new Error('COMPOSITION_INVALID_RATIO');
+    if (id && !exports.FORMAL_COMPOSITIONS.some(item => item.id === id))
+        throw new Error('COMPOSITION_UNKNOWN_ID');
+    return exports.FORMAL_COMPOSITIONS.filter(item => item.supportedKinds.includes(kind) && ratio >= item.aspectRatios.min && ratio <= item.aspectRatios.max && (!id || item.id === id));
+}

package/dist/cjs/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOCIAL_DISPLAY_NUMBERS = exports.compositionParameterDefaults = void 0;
 __exportStar(require("./geometry.js"), exports);
 __exportStar(require("./text.js"), exports);
 __exportStar(require("./scenes.js"), exports);
@@ -29,3 +30,15 @@ __exportStar(require("./designBlueprint.js"), exports);
 __exportStar(require("./compositionScenes.js"), exports);
 __exportStar(require("./editorial.js"), exports);
 __exportStar(require("./fontCatalog.js"), exports);
+__exportStar(require("./candidateRanking.js"), exports);
+__exportStar(require("./styleManifest.js"), exports);
+__exportStar(require("./recipeParameters.js"), exports);
+__exportStar(require("./formalCompositions.js"), exports);
+__exportStar(require("./contentBrief.js"), exports);
+__exportStar(require("./nativeSocialParameters.js"), exports);
+__exportStar(require("./compositionUseCases.js"), exports);
+var parameterDefaults_js_1 = require("./parameterDefaults.js");
+Object.defineProperty(exports, "compositionParameterDefaults", { enumerable: true, get: function () { return parameterDefaults_js_1.compositionParameterDefaults; } });
+var compositionNumbers_js_1 = require("./compositionNumbers.js");
+Object.defineProperty(exports, "SOCIAL_DISPLAY_NUMBERS", { enumerable: true, get: function () { return compositionNumbers_js_1.SOCIAL_DISPLAY_NUMBERS; } });
+__exportStar(require("./textPresentation.js"), exports);

package/dist/cjs/nativeSocialParameters.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPOSITION_ILLUSTRATIONS = void 0;
+exports.nativeSocialParameterContract = nativeSocialParameterContract;
+exports.validateNativeSocialParameters = validateNativeSocialParameters;
+exports.nativeSocialContentPage = nativeSocialContentPage;
+const parameterDefaults_js_1 = require("./parameterDefaults.js");
+const textPresentation_js_1 = require("./textPresentation.js");
+const socialLayouts_js_1 = require("./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.');
+exports.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. */
+function nativeSocialParameterContract(id) {
+    const spec = slots[id];
+    if (!spec || !socialLayouts_js_1.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: exports.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 = (0, textPresentation_js_1.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. */
+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 = (0, parameterDefaults_js_1.compositionParameterDefaults)(schema, raw);
+    if (!check(raw, schema))
+        throw new Error('CANDIDATE_INVALID_PARAMETERS');
+    const values = raw;
+    (0, textPresentation_js_1.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. */
+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/cjs/pagination.js

@@ -5,12 +5,21 @@ exports.splitContent = splitContent;
 /** Split only at explicit word/sentence boundaries. Never cut identifiers,
  * decimal values, or unbroken URLs to force them onto a smaller canvas. */
 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/cjs/parameterDefaults.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionParameterDefaults = compositionParameterDefaults;
+/** Apply only renderer-authored defaults. Never rewrite supplied copy or values. */
+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;
+}