@neatico/visual-core 0.14.3 → 0.14.64

package/dist/contentBrief.d.ts

@@ -0,0 +1,16 @@
+import type { SourceDocument } from "./content.js";
+/** Input provenance and adaptation permissions are independent of suitability scores. */
+export interface ContentBrief {
+    version: 1;
+    originalInput: string;
+    /** Explicitly edited content; the initial submission remains immutable. */
+    revisedInput?: string;
+    revisedInputIllustrative?: boolean;
+    mode: "source-backed" | "creative";
+    language?: string;
+    creativeAllowed: boolean;
+    simulationAllowed: boolean;
+    sourceIds: string[];
+}
+export declare function createContentBrief(source: SourceDocument): ContentBrief;
+export declare function validateContentBrief(value: unknown): ContentBrief;

package/dist/contentBrief.js

@@ -0,0 +1,78 @@
+export function createContentBrief(source) {
+    if (!source ||
+        source.version !== 1 ||
+        typeof source.text !== "string" ||
+        !source.text.trim() ||
+        !Array.isArray(source.segments) ||
+        !source.segments.length)
+        throw new Error("CONTENT_BRIEF_INVALID");
+    const provenance = source.provenance;
+    if (provenance &&
+        (!["creative-draft", "user-revision"].includes(provenance.kind) ||
+            typeof provenance.original !== "string" ||
+            !provenance.original.trim() ||
+            typeof provenance.disclosure !== "string" ||
+            !provenance.disclosure.trim() ||
+            (provenance.originalMode !== undefined &&
+                (provenance.kind !== "user-revision" ||
+                    !["source-backed", "creative"].includes(provenance.originalMode))) ||
+            (provenance.illustrative !== undefined &&
+                (provenance.kind !== "user-revision" || typeof provenance.illustrative !== "boolean")) ||
+            (provenance.simulationAllowed !== undefined &&
+                typeof provenance.simulationAllowed !== "boolean") ||
+            (provenance.language !== undefined &&
+                (typeof provenance.language !== "string" ||
+                    !/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/.test(provenance.language)))))
+        throw new Error("CONTENT_BRIEF_INVALID");
+    const sourceIds = source.segments.map((segment) => segment.id);
+    if (sourceIds.some((id) => typeof id !== "string" || !id) ||
+        new Set(sourceIds).size !== sourceIds.length)
+        throw new Error("CONTENT_BRIEF_INVALID");
+    return validateContentBrief({
+        version: 1,
+        originalInput: provenance?.original || source.text,
+        ...(provenance?.kind === "user-revision" ? { revisedInput: source.text } : {}),
+        ...(provenance?.kind === "user-revision" && provenance.illustrative ? { revisedInputIllustrative: true } : {}),
+        mode: provenance?.kind === "user-revision" ? provenance.originalMode || "source-backed" : provenance ? "creative" : "source-backed",
+        ...(provenance?.language ? { language: provenance.language } : {}),
+        creativeAllowed: true,
+        simulationAllowed: true,
+        sourceIds,
+    });
+}
+export function validateContentBrief(value) {
+    const brief = value;
+    if (!brief ||
+        brief.version !== 1 ||
+        typeof brief.originalInput !== "string" ||
+        !brief.originalInput.trim() ||
+        brief.originalInput.length > 20000 ||
+        (brief.revisedInput !== undefined &&
+            (typeof brief.revisedInput !== "string" || !brief.revisedInput.trim() || brief.revisedInput.length > 20000)) ||
+        (brief.revisedInputIllustrative !== undefined &&
+            (typeof brief.revisedInputIllustrative !== "boolean" || brief.revisedInput === undefined)) ||
+        !["source-backed", "creative"].includes(brief.mode) ||
+        typeof brief.creativeAllowed !== "boolean" ||
+        typeof brief.simulationAllowed !== "boolean" ||
+        (brief.simulationAllowed && !brief.creativeAllowed) ||
+        (brief.language !== undefined &&
+            (typeof brief.language !== "string" ||
+                !/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/.test(brief.language))) ||
+        !Array.isArray(brief.sourceIds) ||
+        !brief.sourceIds.length ||
+        brief.sourceIds.length > 1024 ||
+        new Set(brief.sourceIds).size !== brief.sourceIds.length ||
+        brief.sourceIds.some((id) => typeof id !== "string" || !id || id.length > 160))
+        throw new Error("CONTENT_BRIEF_INVALID");
+    return {
+        version: 1,
+        originalInput: brief.originalInput,
+        ...(brief.revisedInput !== undefined ? { revisedInput: brief.revisedInput } : {}),
+        ...(brief.revisedInputIllustrative !== undefined ? { revisedInputIllustrative: brief.revisedInputIllustrative } : {}),
+        mode: brief.mode,
+        ...(brief.language ? { language: brief.language } : {}),
+        creativeAllowed: brief.creativeAllowed,
+        simulationAllowed: brief.simulationAllowed,
+        sourceIds: [...brief.sourceIds],
+    };
+}

package/dist/designBlueprint.d.ts

@@ -1,4 +1,4 @@
-import { type ContentPage, type SemanticKind } from './content.js';
+import { type ContentPage, type SemanticKind } from "./content.js";
 export interface DesignBlueprint {
     version: 2;
     id: string;
@@ -11,14 +11,14 @@ export interface DesignBlueprint {
         maxBlocks: number;
     };
     layout: {
-        mode: 'stack' | 'split' | 'editorial';
+        mode: "stack" | "split" | "editorial";
         margin: number;
         gap: number;
         titleScale: number;
         bodyScale: number;
         columns: number;
-        surface: 'none' | 'panels' | 'bands';
-        accent: 'none' | 'rail' | 'rule';
+        surface: "none" | "panels" | "bands";
+        accent: "none" | "rail" | "rule";
     };
 }
 export declare const DESIGN_SAMPLE_LOCALES: readonly ["en-US", "zh-CH", "ja-JP", "de-DE", "fr-FR", "es-ES", "pt-PT"];

package/dist/designBlueprint.js

@@ -1,29 +1,104 @@
-import { contentBlockText } from './content.js';
-export const DESIGN_SAMPLE_LOCALES = ['en-US', 'zh-CH', 'ja-JP', 'de-DE', 'fr-FR', 'es-ES', 'pt-PT'];
+import { contentBlockText, } from "./content.js";
+export const DESIGN_SAMPLE_LOCALES = [
+    "en-US",
+    "zh-CH",
+    "ja-JP",
+    "de-DE",
+    "fr-FR",
+    "es-ES",
+    "pt-PT",
+];
 export function validateDesignBlueprint(raw) {
     const v = raw;
-    if (!v || v.version !== 2 || typeof v.id !== 'string' || !/^[a-z][a-z0-9-]{0,79}$/.test(v.id))
-        throw new Error('DESIGN_BLUEPRINT_ID');
-    const kinds = ['paragraph', 'steps', 'features', 'comparison', 'code', 'parameters', 'quote', 'chart', 'image'];
-    if (!Array.isArray(v.kinds) || !v.kinds.length || v.kinds.length > 9 || v.kinds.some(k => !kinds.includes(k)))
-        throw new Error('DESIGN_BLUEPRINT_KINDS');
-    if (!v.labels || typeof v.labels !== 'object' || Array.isArray(v.labels) || typeof v.labels.en !== 'string' || !v.labels.en.trim() || Object.entries(v.labels).some(([key, value]) => !/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(key) || typeof value !== 'string' || !value.trim() || value.length > 120))
-        throw new Error('DESIGN_BLUEPRINT_LABELS');
-    if (!Array.isArray(v.ratios) || !v.ratios.length || v.ratios.length > 8 || v.ratios.some(n => !Number.isFinite(n) || n < .25 || n > 4))
-        throw new Error('DESIGN_BLUEPRINT_RATIOS');
-    const number = (n, min, max) => { if (typeof n !== 'number' || !Number.isFinite(n) || n < min || n > max)
-        throw new Error('DESIGN_BLUEPRINT_RANGE'); return n; };
+    if (!v ||
+        v.version !== 2 ||
+        typeof v.id !== "string" ||
+        !/^[a-z][a-z0-9-]{0,79}$/.test(v.id))
+        throw new Error("DESIGN_BLUEPRINT_ID");
+    const kinds = [
+        "paragraph",
+        "steps",
+        "features",
+        "comparison",
+        "code",
+        "parameters",
+        "quote",
+        "chart",
+        "image",
+    ];
+    if (!Array.isArray(v.kinds) ||
+        !v.kinds.length ||
+        v.kinds.length > 9 ||
+        v.kinds.some((k) => !kinds.includes(k)))
+        throw new Error("DESIGN_BLUEPRINT_KINDS");
+    if (!v.labels ||
+        typeof v.labels !== "object" ||
+        Array.isArray(v.labels) ||
+        typeof v.labels.en !== "string" ||
+        !v.labels.en.trim() ||
+        Object.entries(v.labels).some(([key, value]) => !/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(key) ||
+            typeof value !== "string" ||
+            !value.trim() ||
+            value.length > 120))
+        throw new Error("DESIGN_BLUEPRINT_LABELS");
+    if (!Array.isArray(v.ratios) ||
+        !v.ratios.length ||
+        v.ratios.length > 8 ||
+        v.ratios.some((n) => !Number.isFinite(n) || n < 0.25 || n > 4))
+        throw new Error("DESIGN_BLUEPRINT_RATIOS");
+    const number = (n, min, max) => {
+        if (typeof n !== "number" || !Number.isFinite(n) || n < min || n > max)
+            throw new Error("DESIGN_BLUEPRINT_RANGE");
+        return n;
+    };
     const c = v.capacity, l = v.layout;
     if (!c || !l)
-        throw new Error('DESIGN_BLUEPRINT_MISSING');
-    if (!['stack', 'split', 'editorial'].includes(l.mode) || !['none', 'panels', 'bands'].includes(l.surface) || !['none', 'rail', 'rule'].includes(l.accent))
-        throw new Error('DESIGN_BLUEPRINT_LAYOUT');
+        throw new Error("DESIGN_BLUEPRINT_MISSING");
+    if (!["stack", "split", "editorial"].includes(l.mode) ||
+        !["none", "panels", "bands"].includes(l.surface) ||
+        !["none", "rail", "rule"].includes(l.accent))
+        throw new Error("DESIGN_BLUEPRINT_LAYOUT");
     const maxEntries = number(c.maxEntries, 1, 20), maxBlocks = number(c.maxBlocks, 1, 8), columns = number(l.columns, 1, 4);
     if (![maxEntries, maxBlocks, columns].every(Number.isInteger))
-        throw new Error('DESIGN_BLUEPRINT_INTEGER');
-    return { version: 2, id: v.id, labels: { ...v.labels }, kinds: [...new Set(v.kinds)], ratios: [...new Set(v.ratios)], capacity: { maxCharacters: number(c.maxCharacters, 40, 20000), maxEntries, maxBlocks }, layout: { mode: l.mode, margin: number(l.margin, 32, 80), gap: number(l.gap, 12, 40), titleScale: number(l.titleScale, .8, 1.15), bodyScale: number(l.bodyScale, .9, 1.15), columns, surface: l.surface, accent: l.accent } };
+        throw new Error("DESIGN_BLUEPRINT_INTEGER");
+    return {
+        version: 2,
+        id: v.id,
+        labels: { ...v.labels },
+        kinds: [...new Set(v.kinds)],
+        ratios: [...new Set(v.ratios)],
+        capacity: {
+            maxCharacters: number(c.maxCharacters, 40, 20000),
+            maxEntries,
+            maxBlocks,
+        },
+        layout: {
+            mode: l.mode,
+            margin: number(l.margin, 32, 80),
+            gap: number(l.gap, 12, 40),
+            titleScale: number(l.titleScale, 0.8, 1.15),
+            bodyScale: number(l.bodyScale, 0.9, 1.15),
+            columns,
+            surface: l.surface,
+            accent: l.accent,
+        },
+    };
 }
 export function blueprintFitsContent(blueprint, page, ratio) {
-    const entries = page.blocks.reduce((sum, b) => sum + ('entries' in b ? b.entries.length : 'columns' in b ? b.columns.length : 'rows' in b ? b.rows.length : 'values' in b ? b.values.length : 0), 0);
-    return blueprint.ratios.some(r => Math.abs(r - ratio) < .001) && page.blocks.length <= blueprint.capacity.maxBlocks && page.blocks.every(b => blueprint.kinds.includes(b.kind)) && page.blocks.flatMap(contentBlockText).join('').length <= blueprint.capacity.maxCharacters && entries <= blueprint.capacity.maxEntries;
+    const entries = page.blocks.reduce((sum, b) => sum +
+        ("entries" in b
+            ? b.entries.length
+            : "columns" in b
+                ? b.columns.length
+                : "rows" in b
+                    ? b.rows.length
+                    : "values" in b
+                        ? b.values.length
+                        : 0), 0);
+    return (blueprint.ratios.some((r) => Math.abs(r - ratio) < 0.001) &&
+        page.blocks.length <= blueprint.capacity.maxBlocks &&
+        page.blocks.every((b) => blueprint.kinds.includes(b.kind)) &&
+        page.blocks.flatMap(contentBlockText).join("").length <=
+            blueprint.capacity.maxCharacters &&
+        entries <= blueprint.capacity.maxEntries);
 }

package/dist/designSystem.d.ts

@@ -1,4 +1,4 @@
-import { type ContentPage, type SemanticKind } from './content.js';
+import { type ContentPage, type SemanticKind } from "./content.js";
 export interface DesignTheme {
     id: string;
     palette: {
@@ -18,7 +18,7 @@ export interface DesignTheme {
     geometry: {
         radius: number;
         spacing: number;
-        rule: 'none' | 'hairline' | 'accent';
+        rule: "none" | "hairline" | "accent";
     };
 }
 /** Complete, deterministic token sets; decorative geometry belongs to individual compositions. */
@@ -26,8 +26,8 @@ export declare const DESIGN_THEMES: readonly DesignTheme[];
 export declare function designTheme(id: string): DesignTheme;
 export interface DesignRecipe {
     id: string;
-    renderer: 'catalog' | 'semantic';
-    kind: 'presentation' | 'social';
+    renderer: "catalog" | "semantic";
+    kind: "presentation" | "social";
     family: string;
     accepts: readonly SemanticKind[];
     minEntries: number;
@@ -35,12 +35,16 @@ export interface DesignRecipe {
     requiresImage: boolean;
     /** Unmodelled domain-specific catalogs remain manual-only until their required evidence is expressible. */
     automatic?: boolean;
+    scenes?: readonly string[];
+    manualReason?: string;
 }
-/** Existing authored catalogs remain first-class candidates, rather than being discarded. */
-export declare const DESIGN_RECIPES: readonly DesignRecipe[];
+export declare const MANUAL_COMPOSITION_REASONS: Readonly<Record<string, string>>;
+/** Stable aliases keep saved documents readable while excluding duplicate candidates. */
+export declare function canonicalRecipeId(id: string, kind: DesignRecipe["kind"]): string;
+export declare const DESIGN_RECIPES: DesignRecipe[];
 export declare function pageEntryCount(page: ContentPage): number;
 export interface CandidateContext {
-    kind: DesignRecipe['kind'];
+    kind: DesignRecipe["kind"];
     ratio: number;
     previousFamilies?: readonly string[];
     excluded?: readonly string[];