@aglyn/plugins-ai 1.0.0-beta.233 → 1.0.0-beta.234

package/src/lib/runtime/ai-doctrine-validators.js

@@ -25,7 +25,7 @@ import { parseBreakpointSpan } from "@aglyn/shared-data-enums/breakpoint-span";
 import { renderEmailHtml } from "@aglyn/shared-util-email/email-render";
 import { AI_BUILD_PLAN_CREATION_NOUNS, AI_BUILD_PLAN_EMBED_HOST_NAMES, AI_PLAN_ASKS_FOR_VIDEO, aiEmbedHostOf, aiEmbedVideoKey, aiPlanCreateFor, aiPlanSlugKey, aiPlanUndeclaredRefs, isAiPlanNewRef } from "../model/ai-build-plan.js";
 import { aiCreationNoun, aiPlanCanPlaceForm, aiPlanUncreatable, aiPlanUncreatableKind } from "../model/ai-plan-capabilities.js";
-import { aiFreeSiteSectionsWithin } from "../model/ai-site-job.js";
+import { aiFreeSiteSectionsWithin, aiSiteHomeMinSections, aiSitePlanIsHome } from "../model/ai-site-job.js";
 import { AI_INSTANCE_REF_PROP, validateAiNodeTree } from "./ai-node-tree.js";
 import { AI_PAGE_SCROLL_TO_PROP, aiPageLinkTarget, aiStoredScrollTargets } from "./ai-page-links.js";
 import { AI_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, AI_TEXT_LIMITS, isHeadlineVariant } from "./ai-palette.js";
@@ -277,6 +277,22 @@ function listNames(ids, tree) {
  */ export function detectRepeatedSubtrees(tree, otherPages = [], context = {}) {
     if (context.reusableComponents === false) return [];
     const index = indexShapes(tree);
+    /**
+   * A compiled picture card (AGL-3660): a Stack that opens with its picture,
+   * in a cell of a grid — or that cell, holding only the card.
+   */ const card = (id)=>{
+        var _node_nodes, _tree_nodes_first;
+        const node = id === undefined ? undefined : tree.nodes[id];
+        const first = node == null ? void 0 : (_node_nodes = node.nodes) == null ? void 0 : _node_nodes[0];
+        return (node == null ? void 0 : node.componentId) === 'muiStack' && first !== undefined && ((_tree_nodes_first = tree.nodes[first]) == null ? void 0 : _tree_nodes_first.componentId) === 'image';
+    };
+    const pictureCard = (id)=>{
+        var _node_props, _node_nodes, _index_visits_find, _tree_nodes_parentId;
+        const node = tree.nodes[id];
+        if ((node == null ? void 0 : node.componentId) === 'muiGrid' && ((_node_props = node.props) == null ? void 0 : _node_props['container']) !== true) return ((_node_nodes = node.nodes) == null ? void 0 : _node_nodes.length) === 1 && card(node.nodes[0]);
+        const parentId = (_index_visits_find = index.visits.find((visit)=>visit.id === id)) == null ? void 0 : _index_visits_find.ancestors.at(-1);
+        return card(id) && parentId !== undefined && ((_tree_nodes_parentId = tree.nodes[parentId]) == null ? void 0 : _tree_nodes_parentId.componentId) === 'muiGrid';
+    };
     const violations = repeatedShapes(tree, index, AI_REPEAT_MIN_NODES, AI_REPEAT_MIN_COUNT, // Counted within the band of the page it sits in (AGL-3660), as rule 8
     // counts a typed list: a heading over its words in the About band and in
     // the Services band are two parts of two stories, not one block placed twice.
@@ -288,7 +304,7 @@ function listNames(ids, tree) {
             var _tree_nodes_id;
             return ((_tree_nodes_id = tree.nodes[id]) == null ? void 0 : _tree_nodes_id.componentId) === 'section';
         })) != null ? _reverse_find : tree.rootId;
-    }, aiRepeatFrameOrSection(tree)).map(({ ids })=>{
+    }, aiRepeatFrameOrSection(tree)).filter(({ ids })=>!(context.repeatsCompiled && ids.every(pictureCard))).map(({ ids })=>{
         const name = displayName(tree.nodes[ids[0]].componentId);
         return {
             rule: 1,
@@ -729,6 +745,199 @@ function normalizeHex(value) {
         }
     ];
 }
+/** The props an email block is colored by, the ones rule 6 reads. */ const EMAIL_COLOR_PROPS = [
+    'color',
+    'backgroundColor'
+];
+/**
+ * A color as opaque RGB: hex of 3, 4, 6 or 8 digits, or `rgb()`/`rgba()`. A
+ * translucent value is laid over white, the page an email is read on. `null`
+ * for anything else, a name or a token included.
+ */ function emailRgbOf(value) {
+    var _exec;
+    const text = value.trim().toLowerCase();
+    const hex = (_exec = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.exec(text)) == null ? void 0 : _exec[1];
+    let r;
+    let g;
+    let b;
+    let alpha = 1;
+    if (hex) {
+        const full = hex.length <= 4 ? [
+            ...hex
+        ].map((digit)=>digit + digit).join('') : hex;
+        r = parseInt(full.slice(0, 2), 16);
+        g = parseInt(full.slice(2, 4), 16);
+        b = parseInt(full.slice(4, 6), 16);
+        if (full.length === 8) alpha = parseInt(full.slice(6, 8), 16) / 255;
+    } else {
+        const fn = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/.exec(text);
+        if (!fn) return null;
+        r = Number(fn[1]);
+        g = Number(fn[2]);
+        b = Number(fn[3]);
+        if (fn[4] !== undefined) alpha = Number(fn[4]);
+        if (![
+            r,
+            g,
+            b,
+            alpha
+        ].every(Number.isFinite) || r > 255 || g > 255 || b > 255 || alpha > 1) return null;
+    }
+    const over = (channel)=>Math.round(channel * alpha + 255 * (1 - alpha));
+    return {
+        r: over(r),
+        g: over(g),
+        b: over(b),
+        alpha
+    };
+}
+/** How far apart two colors look: the weighted "redmean" RGB distance. */ function emailColorDistance(a, b) {
+    const mean = (a.r + b.r) / 2;
+    const dr = a.r - b.r;
+    const dg = a.g - b.g;
+    const db = a.b - b.b;
+    return Math.sqrt((2 + mean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - mean) / 256) * db * db);
+}
+/**
+ * An email's off-brand colors, settled where each has one reading (AGL-3676).
+ * Rule 6 holds an email to the brand's own values, and the guided start's
+ * welcome email kept writing tints of them — a pale wash of the primary color
+ * behind a section — and stopped on rule 6 after its re-ask. Before the tree
+ * is checked, each `color` and `backgroundColor` outside the brand is:
+ *
+ *  - a palette path the brand lists, such as `primary.main`: its value;
+ *  - a color that parses: the NEAREST opaque brand color, so a pale tint
+ *    becomes the brand's pale surface and a deep one its deep color;
+ *  - with no brand color recorded at all: dropped, leaving the block's own
+ *    default, which is what rule 6 asks of an email with no brand.
+ *
+ * A value that does not parse (a name, a CSS variable) is left for the
+ * re-ask, and so is the whole tree when a snapped color would leave words
+ * below 3:1 against what they sit on. Nothing is relaxed: the settled tree
+ * is the one rule 6 checks.
+ * Reads and returns the tree as the model wrote it.
+ */ export function aiSettleOffBrandEmailColors(input, brand) {
+    var _ref;
+    if (!isRecord(input) || !isRecord(input['nodes'])) return input;
+    const entries = Object.entries((_ref = brand == null ? void 0 : brand.colors) != null ? _ref : {}).filter((entry)=>typeof entry[1] === 'string' && entry[1].trim() !== '');
+    const allowed = new Set(entries.map(([, value])=>normalizeHex(value)));
+    const byPath = new Map(entries.map(([path, value])=>[
+            path.toLowerCase(),
+            value.trim()
+        ]));
+    const targets = entries.flatMap(([, value])=>{
+        const rgb = emailRgbOf(value);
+        return rgb && rgb.alpha === 1 ? [
+            {
+                value: value.trim(),
+                rgb
+            }
+        ] : [];
+    });
+    const settle = (value)=>{
+        if (!entries.length) return null;
+        const named = byPath.get(value.trim().toLowerCase());
+        if (named) return named;
+        const rgb = emailRgbOf(value);
+        if (!rgb || !targets.length) return undefined;
+        let best = targets[0];
+        for (const target of targets){
+            if (emailColorDistance(rgb, target.rgb) < emailColorDistance(rgb, best.rgb)) best = target;
+        }
+        return best.value;
+    };
+    let nodes = null;
+    for (const [id, node] of Object.entries(input['nodes'])){
+        if (!isRecord(node) || !isRecord(node['props'])) continue;
+        let props = null;
+        for (const name of EMAIL_COLOR_PROPS){
+            const value = node['props'][name];
+            if (typeof value !== 'string' || !value.trim() || allowed.has(normalizeHex(value))) continue;
+            const settled = settle(value);
+            if (settled === undefined) continue;
+            props != null ? props : props = _extends({}, node['props']);
+            if (settled === null) delete props[name];
+            else props[name] = settled;
+        }
+        if (!props) continue;
+        nodes != null ? nodes : nodes = _extends({}, input['nodes']);
+        nodes[id] = _extends({}, node, {
+            props
+        });
+    }
+    if (!nodes || !targets.length) return nodes ? _extends({}, input, {
+        nodes
+    }) : input;
+    // Two colors snapped onto one brand value can leave words the color of what
+    // they sit on — a pale green heading on a cream band both become the cream.
+    // A settle that leaves any color it touched unreadable is not one reading,
+    // so the tree goes back as written and rule 6 asks the model.
+    return emailSettleKeepsContrast(input['nodes'], nodes) ? _extends({}, input, {
+        nodes
+    }) : input;
+}
+/** The least contrast words keep on what they sit on once settled: WCAG's large-text floor. */ const EMAIL_SETTLED_MIN_CONTRAST = 3;
+function emailLuminance({ r, g, b }) {
+    const channel = (value)=>{
+        const c = value / 255;
+        return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}
+function emailContrast(a, b) {
+    const [light, dark] = [
+        emailLuminance(a),
+        emailLuminance(b)
+    ].sort((x, y)=>y - x);
+    return (light + 0.05) / (dark + 0.05);
+}
+/**
+ * Whether every block whose words or ground the settle changed can still be
+ * read: its `color` against its own `backgroundColor` (a button's fill), else
+ * the nearest enclosing one, else the white an email is read on. A button
+ * with no fill of its own is left out: its fill is the block's default.
+ */ function emailSettleKeepsContrast(written, settled) {
+    const parentOf = new Map();
+    for (const [id, node] of Object.entries(settled)){
+        if (!isRecord(node) || !Array.isArray(node['nodes'])) continue;
+        for (const child of node['nodes'])if (typeof child === 'string') parentOf.set(child, id);
+    }
+    const propOf = (nodes, id, name)=>{
+        const node = nodes[id];
+        return isRecord(node) && isRecord(node['props']) ? node['props'][name] : undefined;
+    };
+    /** The id whose background a node's words sit on, or `null` for the email's white. */ const groundOf = (id)=>{
+        if (typeof propOf(settled, id, 'backgroundColor') === 'string') return id;
+        const node = settled[id];
+        if (isRecord(node) && node['componentId'] === 'emailButton') return undefined;
+        const seen = new Set([
+            id
+        ]);
+        for(let at = parentOf.get(id); at && !seen.has(at); at = parentOf.get(at)){
+            seen.add(at);
+            if (typeof propOf(settled, at, 'backgroundColor') === 'string') return at;
+        }
+        return null;
+    };
+    const WHITE = {
+        r: 255,
+        g: 255,
+        b: 255
+    };
+    for (const id of Object.keys(settled)){
+        const color = propOf(settled, id, 'color');
+        if (typeof color !== 'string') continue;
+        const ground = groundOf(id);
+        if (ground === undefined) continue;
+        const touched = color !== propOf(written, id, 'color') || ground !== null && propOf(settled, ground, 'backgroundColor') !== propOf(written, ground, 'backgroundColor');
+        if (!touched) continue;
+        const text = emailRgbOf(color);
+        const background = ground === null ? WHITE : emailRgbOf(String(propOf(settled, ground, 'backgroundColor')));
+        if (!text || !background) continue;
+        if (emailContrast(text, background) < EMAIL_SETTLED_MIN_CONTRAST) return false;
+    }
+    return true;
+}
 /**
  * Rule 8 (tree). A long list typed out item by item is data: bound to a
  * dataset or a content collection it stays current; typed, it is a copy that
@@ -3692,9 +3901,12 @@ function slugKey(slug) {
             }
         ];
     }
+    // A site start's saved form is a step of its own (AGL-3596), counted on the wall since AGL-3660.
+    const forms = plan.create.filter((entry)=>entry.kind === 'form').length - aiPlanUncreatable(plan, capabilities).filter((entry)=>entry.kind === 'form').length;
     const fits = sitePages !== undefined ? aiFreeSiteSectionsWithin({
         layouts,
-        pages
+        pages,
+        forms: Math.max(0, forms)
     }, FREE_AI_TASTE_CREDITS_PER_MONTH) : aiFreePageSectionsWithin({
         layouts,
         pages
@@ -3702,11 +3914,22 @@ function slugKey(slug) {
     if (asked <= fits) return [];
     const job = pages > 1 ? `a Free plan of ${pages} pages` : 'a Free page';
     const beside = layouts ? ` that creates ${layouts > 1 ? `${layouts} layouts` : 'its layout'}` : '';
+    // A site start's home keeps its full five (AGL-3660): told only "plan at
+    // most 8", the live yoga start of 2026-10-08 cut a home of 6 to 4 and kept
+    // its other page, so the redo names where the sections come from.
+    const homeMin = sitePages !== undefined && plan.screens.some(aiSitePlanIsHome) ? aiSiteHomeMinSections({
+        pages,
+        across: fits
+    }) : 0;
+    const keepHome = homeMin ? ` Keep the home page at / at ${homeMin} or more sections, and take the rest from the other ${pages > 2 ? 'pages' : 'page'}.` : '';
+    // A site start's redo keeps the plan full (AGL-3660): the wall's sections
+    // are its budget to use, and a redo told only "at most" cuts far under it.
+    const redo = sitePages !== undefined && fits >= 2 ? `Plan ${fits - 1} to ${fits}: the ${fits} are the budget to use, not a ceiling to stay under. Draw a list's repeated items in one section, and take out only the sections the brief needs least.` : `Plan at most ${fits}: draw a list's repeated items in one section, and leave out a section the brief does not ask for.`;
     return [
         {
             rule: null,
             code: 'plan-over-free-wall',
-            message: `This plan asks for ${asked} sections, and ${job}${beside} fits ${fits} in the ${FREE_AI_TASTE_CREDITS_PER_MONTH} AI credits a Free workspace has a month. Plan at most ${fits}: draw a list's repeated items in one section, and leave out a section the brief does not ask for.`,
+            message: `This plan asks for ${asked} sections, and ${job}${beside} fits ${fits} in the ${FREE_AI_TASTE_CREDITS_PER_MONTH} AI credits a Free workspace has a month. ${redo}${keepHome}`,
             paths: plan.screens.map((_, index)=>`screens[${index}].sections`)
         }
     ];