@aglyn/plugins-ai 1.0.0-beta.285 → 1.0.0-beta.288

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

@@ -30,7 +30,7 @@ import { aiFreeSiteSectionsWithin, aiSiteHomeMinSections, aiSitePlanIsHome, aiSi
 import { aiLayoutIsShopPage, aiLayoutShopGridSection } from "../layout-language/ai-layout-listings.js";
 import { aiStorefrontSays } from "../layout-language/ai-layout-storefront.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_PAGE_SCROLL_TO_PROP, aiPageLinkTarget, aiStoredScrollTargets, isAiFragmentHref } from "./ai-page-links.js";
 import { AI_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, AI_TEXT_LIMITS, isHeadlineVariant } from "./ai-palette.js";
 import { AI_PALETTE, AI_SX_TOKENS } from "./ai-palette.generated.js";
 import { aiIsOnlyPlaceholders, aiPlaceholderTokens } from "./ai-placeholder-tokens.js";
@@ -2151,6 +2151,162 @@ const GRID = 'muiGrid';
     }
     return violations;
 }
+/** The longest send label a Form takes, as its palette entry bounds `submitLabel`. */ const FORM_SUBMIT_LABEL_MAX = 40;
+/** The frames a link may be the last thing in, taken out with it rather than left empty. */ const LINK_FRAMES = new Set([
+    'muiBox',
+    'muiStack',
+    'muiContainer',
+    'muiGrid',
+    'section',
+    'div',
+    'muiCardActions'
+]);
+/**
+ * The links `detectLinksWithoutDestination` would refuse as going nowhere
+ * (`link-without-destination`) or to an anchor no section has
+ * (`link-fragment`), read conservatively: a link whose `screenId` names a page
+ * the site has, whose `href` is anything but a fragment, that carries a Scroll
+ * to element interaction to a section of its page, or whose `scrollTo` the
+ * check reads on its own terms (`scroll-target-unknown`), is not one. A tree
+ * as written is read as the check will read it once the palette validator has
+ * dropped the fragment.
+ */ function linksWithoutDestination(tree, outputKind, context) {
+    var _context_pageSections;
+    if (outputKind === 'email' || outputKind === 'form') return [];
+    const sections = (_context_pageSections = context.pageSections) != null ? _context_pageSections : [];
+    const targets = context.scrollTargetIds ? new Set(context.scrollTargetIds) : null;
+    const known = context.screenIds ? new Set(context.screenIds) : null;
+    const written = (id)=>context.writtenNode ? context.writtenNode(id) : tree.nodes[id];
+    const found = [];
+    for (const visit of walkTree(tree)){
+        var _reverse_find;
+        var _node_props, _node_props1, _node_props2;
+        const { node } = visit;
+        if (!LINK_COMPONENTS.has(node.componentId)) continue;
+        const screenId = (_node_props = node.props) == null ? void 0 : _node_props['screenId'];
+        if (isFilled(screenId) && (!known || known.has(String(screenId).trim()))) continue;
+        const href = (_node_props1 = node.props) == null ? void 0 : _node_props1['href'];
+        if (isFilled(href) && !isAiFragmentHref(href)) continue;
+        const scrolls = aiStoredScrollTargets(node);
+        if (scrolls.length && (!targets || scrolls.some((target)=>targets.has(target)))) continue;
+        const target = aiPageLinkTarget(written(visit.id), sections);
+        if ((target == null ? void 0 : target.kind) === 'section' || (target == null ? void 0 : target.kind) === 'unknown' && target.via === 'scrollTo') continue;
+        const label = typeof ((_node_props2 = node.props) == null ? void 0 : _node_props2['children']) === 'string' ? node.props['children'].trim() : '';
+        const form = (_reverse_find = [
+            ...visit.ancestors
+        ].reverse().find((id)=>{
+            var _tree_nodes_id;
+            return ((_tree_nodes_id = tree.nodes[id]) == null ? void 0 : _tree_nodes_id.componentId) === 'form';
+        })) != null ? _reverse_find : null;
+        found.push({
+            id: visit.id,
+            label,
+            form
+        });
+    }
+    return found;
+}
+/**
+ * RULE 10'S LINK THAT GOES NOWHERE, SETTLED IN CODE (AGL-4076).
+ *
+ * A Button or a Page Link with no destination (`link-without-destination`),
+ * or one sent to an anchor no section of its page has (`link-fragment`),
+ * stopped 5 of the 12 findings behind the 10/10 to 10/28 doctrine stops: the
+ * re-ask is spent, the job stops, and Try again asks the same. Each has one
+ * answer the rule itself gives, so it is applied before the check reads the
+ * tree, as `aiSettleUnrelatedScreenLinks` settles a link sent home:
+ *
+ * - a button drawn inside a Form is taken out, since the Form draws its own
+ *   send button; its words become the Form's `submitLabel` when the Form has
+ *   none of its own;
+ * - a link whose words ask a visitor to get in touch is sent to the page that
+ *   places the site's form, when the site has one that is not this page;
+ * - any other is left out: no page can be chosen for it from its words alone.
+ *
+ * A frame the link was the last thing in is taken out with it rather than
+ * left empty, up to the page's own sections, which always stay. A link to a
+ * section of its page, to a page the site has, or to any address is never
+ * touched, and nor is one whose `scrollTo` names no section, which the check
+ * re-asks as before. The root is never taken out. A tree with nothing to
+ * settle comes back as the same object; a node that is changed is copied.
+ */ export function aiSettleLinksWithoutDestination(tree, outputKind, context = {}) {
+    var _context_ownScreenIds, _find, _context_formScreenIds, _tree_nodes_tree_rootId_nodes, _context_scrollTargetIds;
+    if (!tree.nodes[tree.rootId]) return tree;
+    const found = linksWithoutDestination(tree, outputKind, context);
+    if (!found.length) return tree;
+    const own = new Set((_context_ownScreenIds = context.ownScreenIds) != null ? _context_ownScreenIds : []);
+    const formScreen = (_find = ((_context_formScreenIds = context.formScreenIds) != null ? _context_formScreenIds : []).find((id)=>!own.has(id))) != null ? _find : null;
+    // A page's sections, and anything a link scrolls to, always stay.
+    const kept = new Set([
+        tree.rootId,
+        ...(_tree_nodes_tree_rootId_nodes = tree.nodes[tree.rootId].nodes) != null ? _tree_nodes_tree_rootId_nodes : [],
+        ...(_context_scrollTargetIds = context.scrollTargetIds) != null ? _context_scrollTargetIds : []
+    ]);
+    const nodes = _extends({}, tree.nodes);
+    const parents = new Map();
+    for (const visit of walkTree(tree)){
+        const parent = visit.ancestors[visit.ancestors.length - 1];
+        if (parent !== undefined) parents.set(visit.id, parent);
+    }
+    let changed = false;
+    const takeOut = (id)=>{
+        let next = id;
+        while(next !== undefined && nodes[next] && !kept.has(next)){
+            var _nodes_parent_nodes;
+            const parent = parents.get(next);
+            if (parent === undefined || !nodes[parent]) return;
+            const children = ((_nodes_parent_nodes = nodes[parent].nodes) != null ? _nodes_parent_nodes : []).filter((child)=>child !== next);
+            nodes[parent] = _extends({}, nodes[parent], {
+                nodes: children
+            });
+            changed = true;
+            const stack = [
+                next
+            ];
+            while(stack.length){
+                var _ref;
+                var _nodes_gone;
+                const gone = stack.pop();
+                stack.push(...(_ref = (_nodes_gone = nodes[gone]) == null ? void 0 : _nodes_gone.nodes) != null ? _ref : []);
+                delete nodes[gone];
+            }
+            next = !children.some((child)=>nodes[child]) && LINK_FRAMES.has(nodes[parent].componentId) ? parent : undefined;
+        }
+    };
+    for (const { id, label, form } of found){
+        if (!nodes[id]) continue;
+        if (form && nodes[form]) {
+            var _nodes_form_props;
+            if (label && label.length <= FORM_SUBMIT_LABEL_MAX && !isFilled((_nodes_form_props = nodes[form].props) == null ? void 0 : _nodes_form_props['submitLabel'])) {
+                var _nodes_form_props1;
+                nodes[form] = _extends({}, nodes[form], {
+                    props: _extends({}, (_nodes_form_props1 = nodes[form].props) != null ? _nodes_form_props1 : {}, {
+                        submitLabel: label
+                    })
+                });
+                changed = true;
+            }
+            takeOut(id);
+            continue;
+        }
+        if (formScreen && label && aiAsksToGetInTouch(label)) {
+            var _nodes_id_props;
+            const props = _extends({}, (_nodes_id_props = nodes[id].props) != null ? _nodes_id_props : {}, {
+                screenId: formScreen
+            });
+            delete props['href'];
+            nodes[id] = _extends({}, nodes[id], {
+                props
+            });
+            changed = true;
+            continue;
+        }
+        takeOut(id);
+    }
+    return changed ? _extends({}, tree, {
+        nodes
+    }) : tree;
+}
 /** Answer fields that say "publish", wherever the answer put them. */ const PUBLISH_KEYS = /^(?:publish|published|publishNow|publishAt|goLive|isLive|live|makeLive)$/i;
 /**
  * Rule 13. The AI writes drafts. An answer that asks for anything to be
@@ -2613,6 +2769,29 @@ const EMBED_COMPONENTS = new Set([
 ]);
 const DUPLICATE_SX_MIN_KEYS = 2;
 const DUPLICATE_SX_MIN_NODES = 4;
+/**
+ * Rule 16's repeated style: the elements whose `sx` is one style of at least
+ * `DUPLICATE_SX_MIN_KEYS` keys, grouped by that style, each group of at least
+ * `DUPLICATE_SX_MIN_NODES` elements, in document order.
+ */ function duplicatedSxGroups(tree) {
+    const seen = new Map();
+    for (const { id, node } of walkTree(tree)){
+        var _node_sx, _seen_get;
+        const sx = (_node_sx = node.sx) != null ? _node_sx : {};
+        if (Object.keys(sx).length < DUPLICATE_SX_MIN_KEYS) continue;
+        const key = JSON.stringify(Object.keys(sx).sort().map((name)=>[
+                name,
+                sx[name]
+            ]));
+        seen.set(key, [
+            ...(_seen_get = seen.get(key)) != null ? _seen_get : [],
+            id
+        ]);
+    }
+    return [
+        ...seen.values()
+    ].filter((ids)=>ids.length >= DUPLICATE_SX_MIN_NODES);
+}
 /**
  * Whether a third-party player is one the confirmed plan lists (AGL-3433). A
  * Video embed is admitted where the plan lists a player, playing the video
@@ -2648,11 +2827,10 @@ const DUPLICATE_SX_MIN_NODES = 4;
     const video = [];
     const embeds = [];
     const embedLinks = [];
-    const sxSeen = new Map();
     let images = 0;
     for (const { id, node } of visits){
-        var _node_nodes, _node_props, _node_sx, _node_sx1;
-        var _node_props1, _node_sx2, _node_props2, _node_props3, _node_props4, _node_props5;
+        var _node_nodes, _node_props, _node_sx;
+        var _node_props1, _node_sx1, _node_props2, _node_props3, _node_props4, _node_props5;
         const entry = AI_PALETTE[node.componentId];
         const children = ((_node_nodes = node.nodes) != null ? _node_nodes : []).filter((child)=>tree.nodes[child]);
         const ownProps = Object.entries((_node_props = node.props) != null ? _node_props : {}).filter(([name, value])=>!(name === 'component' && value === 'div'));
@@ -2663,7 +2841,7 @@ const DUPLICATE_SX_MIN_NODES = 4;
         if ((entry == null ? void 0 : entry.acceptsChildren) && !children.length && !boundForm && !OWNS_ITS_EMPTY_STATE.has(node.componentId)) {
             empty.push(id);
         }
-        if (outputKind !== 'email' && ((_node_sx2 = node.sx) == null ? void 0 : _node_sx2['fontFamily']) !== undefined) fonts.push(id);
+        if (outputKind !== 'email' && ((_node_sx1 = node.sx) == null ? void 0 : _node_sx1['fontFamily']) !== undefined) fonts.push(id);
         if (node.componentId === 'image') {
             var _node_props6;
             images += 1;
@@ -2678,22 +2856,8 @@ const DUPLICATE_SX_MIN_NODES = 4;
             if (verdict === 'unplanned') embeds.push(id);
             if (verdict === 'unplanned-link') embedLinks.push(id);
         }
-        const sx = (_node_sx1 = node.sx) != null ? _node_sx1 : {};
-        if (Object.keys(sx).length >= DUPLICATE_SX_MIN_KEYS) {
-            var _sxSeen_get;
-            const key = JSON.stringify(Object.keys(sx).sort().map((name)=>[
-                    name,
-                    sx[name]
-                ]));
-            sxSeen.set(key, [
-                ...(_sxSeen_get = sxSeen.get(key)) != null ? _sxSeen_get : [],
-                id
-            ]);
-        }
     }
-    const duplicatedSx = [
-        ...sxSeen.values()
-    ].filter((ids)=>ids.length >= DUPLICATE_SX_MIN_NODES).flat();
+    const duplicatedSx = duplicatedSxGroups(tree).flat();
     const violations = [];
     const add = (code, ids, message)=>{
         if (ids.length) violations.push({
@@ -3416,6 +3580,52 @@ const BUDGET_METRICS = [
     }) : input;
 }
 // ── Mechanical rules, settled in code (AGL-3660) ─────────────────────────
+/** The inherited styles a repeated style may be carried once in, by the frame that holds every element repeating it (AGL-4076). */ const HOISTED_SX_KEYS = [
+    'textAlign',
+    'color'
+];
+/**
+ * The elements that take each of those styles from their parent when they set
+ * none themselves, which are also the frames that may carry one for the
+ * elements they hold: none of them draws anything of its own in it.
+ */ const INHERITS_SX = {
+    // A Typography aligns as `inherit` unless its `align` says otherwise; a Card and a Paper set no alignment.
+    textAlign: new Set([
+        'muiTypography',
+        'muiBox',
+        'muiStack',
+        'muiGrid',
+        'muiContainer',
+        'section',
+        'div',
+        'muiCardContent',
+        'muiCard',
+        'muiPaper'
+    ]),
+    // A Card and a Paper paint their own text color, and a Button, a link and a list row theirs.
+    color: new Set([
+        'muiTypography',
+        'muiBox',
+        'muiStack',
+        'muiGrid',
+        'muiContainer',
+        'section',
+        'div',
+        'muiCardContent'
+    ])
+};
+/** A Typography's `align` values, which draw exactly what the same `sx` text alignment does. */ const TYPOGRAPHY_ALIGNS = new Set([
+    'inherit',
+    'left',
+    'center',
+    'right',
+    'justify'
+]);
+/** An `sx` without one key. */ function sxWithout(sx, key) {
+    const rest = _extends({}, sx != null ? sx : {});
+    delete rest[key];
+    return rest;
+}
 /**
  * THE RULES A CHECK WOULD REFUSE FOR AN ATTRIBUTE, SETTLED IN CODE (AGL-3660).
  *
@@ -3451,11 +3661,20 @@ const BUDGET_METRICS = [
  * - `page-text-on-band` (5): words on a band in a family's main or dark shade
  *   whose `sx` color is a page text color (`text.secondary`) are given the
  *   family's contrast text, and a List Item Text's secondary words there take
- *   the row's own color (`secondaryColor: inherit`).
+ *   the row's own color (`secondaryColor: inherit`);
+ * - `duplicated-inline-style` (16), where the style can be carried once
+ *   without changing what is drawn (AGL-4076): when the elements repeating it
+ *   are every element of one frame, its text alignment and its text color
+ *   move to that frame, which they inherit from, and a Typography's text
+ *   alignment becomes its `align`. Only where that leaves fewer repeats; a
+ *   repeated padding, size or border has no single place to go and is still
+ *   the re-ask's;
+ * - `link-without-destination` and `link-fragment` (10), given `links`, the
+ *   context the check reads links in (`aiSettleLinksWithoutDestination`).
  *
  * A tree with nothing to settle comes back as the same object, so settling is
  * idempotent; a node that is changed is copied, never edited in place.
- */ export function aiSettleMechanicalRules(tree, outputKind) {
+ */ export function aiSettleMechanicalRules(tree, outputKind, links) {
     if (!tree.nodes[tree.rootId]) return tree;
     const nodes = _extends({}, tree.nodes);
     const copied = new Set();
@@ -3590,25 +3809,122 @@ const BUDGET_METRICS = [
             });
         }
     }
-    return copied.size ? _extends({}, tree, {
+    // Rule 16: a style a group of elements repeats, carried once where it draws the same (AGL-4076).
+    if (framed) {
+        const parentOf = new Map();
+        for (const visit of walkTree({
+            rootId: tree.rootId,
+            nodes
+        })){
+            const parent = visit.ancestors[visit.ancestors.length - 1];
+            if (parent !== undefined) parentOf.set(visit.id, parent);
+        }
+        const heavy = ()=>detectHeavyDocument({
+                rootId: tree.rootId,
+                nodes
+            }, outputKind).reduce((sum, violation)=>{
+                var _ref;
+                var _violation_nodeIds;
+                return sum + ((_ref = (_violation_nodeIds = violation.nodeIds) == null ? void 0 : _violation_nodeIds.length) != null ? _ref : 0);
+            }, 0);
+        for (const group of duplicatedSxGroups({
+            rootId: tree.rootId,
+            nodes
+        })){
+            var _ref, _ref1;
+            var _nodes_group_, _nodes_parent;
+            const style = (_ref = (_nodes_group_ = nodes[group[0]]) == null ? void 0 : _nodes_group_.sx) != null ? _ref : {};
+            const same = JSON.stringify(Object.keys(style).sort().map((name)=>[
+                    name,
+                    style[name]
+                ]));
+            const alike = group.every((id)=>{
+                var _ref;
+                var _nodes_id;
+                const sx = (_ref = (_nodes_id = nodes[id]) == null ? void 0 : _nodes_id.sx) != null ? _ref : {};
+                return JSON.stringify(Object.keys(sx).sort().map((name)=>[
+                        name,
+                        sx[name]
+                    ])) === same;
+            });
+            if (!alike) continue;
+            const before = heavy();
+            const replaced = new Map();
+            const wasCopied = new Set(copied);
+            const put = (id, node)=>{
+                if (!replaced.has(id)) replaced.set(id, nodes[id]);
+                nodes[id] = node;
+                copied.add(id);
+            };
+            const parent = parentOf.get(group[0]);
+            const held = parent !== undefined ? ((_ref1 = (_nodes_parent = nodes[parent]) == null ? void 0 : _nodes_parent.nodes) != null ? _ref1 : []).filter((child)=>nodes[child]) : [];
+            const whole = parent !== undefined && parent !== tree.rootId && held.length === group.length && group.every((id)=>parentOf.get(id) === parent);
+            for (const key of whole ? HOISTED_SX_KEYS : []){
+                var _holder_sx, _holder_sx1;
+                var _holder_sx2;
+                const holder = nodes[parent];
+                if (style[key] === undefined || !INHERITS_SX[key].has(holder.componentId)) continue;
+                if (!group.every((id)=>INHERITS_SX[key].has(nodes[id].componentId))) continue;
+                const own = (_holder_sx2 = holder.sx) == null ? void 0 : _holder_sx2[key];
+                if (own !== undefined && JSON.stringify(own) !== JSON.stringify(style[key])) continue;
+                // A border drawn in the frame's own text color would take the new one.
+                if (key === 'color' && Object.keys((_holder_sx = holder.sx) != null ? _holder_sx : {}).some((name)=>/^(?:border|outline)/.test(name))) continue;
+                put(parent, _extends({}, holder, {
+                    sx: _extends({}, (_holder_sx1 = holder.sx) != null ? _holder_sx1 : {}, {
+                        [key]: style[key]
+                    })
+                }));
+                for (const id of group)put(id, _extends({}, nodes[id], {
+                    sx: sxWithout(nodes[id].sx, key)
+                }));
+            }
+            for (const id of group){
+                var _node_props7;
+                var _node_sx4, _node_props8;
+                const node = nodes[id];
+                const align = (_node_sx4 = node.sx) == null ? void 0 : _node_sx4['textAlign'];
+                if (node.componentId !== 'muiTypography' || typeof align !== 'string' || !TYPOGRAPHY_ALIGNS.has(align)) continue;
+                if (((_node_props8 = node.props) == null ? void 0 : _node_props8['align']) !== undefined && node.props['align'] !== 'inherit') continue;
+                put(id, _extends({}, node, {
+                    props: _extends({}, (_node_props7 = node.props) != null ? _node_props7 : {}, {
+                        align
+                    }),
+                    sx: sxWithout(node.sx, 'textAlign')
+                }));
+            }
+            // Kept only where it leaves the page lighter by the rule's own measure.
+            if (replaced.size && heavy() >= before) {
+                for (const [id, node] of replaced)nodes[id] = node;
+                copied.clear();
+                for (const id of wasCopied)copied.add(id);
+            }
+        }
+    }
+    const settled = copied.size ? _extends({}, tree, {
         nodes
     }) : tree;
+    return links ? aiSettleLinksWithoutDestination(settled, outputKind, links) : settled;
 }
 /**
  * `aiSettleMechanicalRules` on a tree as the model wrote it, before the
  * palette validator reads it (AGL-3660), as `aiSettleWrittenGridItems` settles
  * its items. Anything that is no flat node map comes back as it was, and a
  * node whose shape is not a palette node's is read as nothing and left as written.
- */ export function aiSettleWrittenMechanicalRules(input, outputKind) {
+ * Given `links`, a link that goes nowhere is settled too (AGL-4076), and a
+ * node that takes out is gone from the answer.
+ */ export function aiSettleWrittenMechanicalRules(input, outputKind, links) {
     if (!isRecord(input) || typeof input['rootId'] !== 'string' || !isRecord(input['nodes'])) return input;
     const readable = Object.entries(input['nodes']).filter(([, node])=>isRecord(node) && typeof node['componentId'] === 'string' && (node['props'] === undefined || isRecord(node['props'])) && (node['sx'] === undefined || isRecord(node['sx'])) && (node['nodes'] === undefined || Array.isArray(node['nodes']) && node['nodes'].every((child)=>typeof child === 'string')));
     const tree = {
         rootId: input['rootId'],
         nodes: Object.fromEntries(readable)
     };
-    const settled = aiSettleMechanicalRules(tree, outputKind);
-    return settled === tree ? input : _extends({}, input, {
-        nodes: _extends({}, input['nodes'], settled.nodes)
+    const settled = aiSettleMechanicalRules(tree, outputKind, links);
+    if (settled === tree) return input;
+    const nodes = _extends({}, input['nodes'], settled.nodes);
+    for (const id of Object.keys(tree.nodes))if (!settled.nodes[id]) delete nodes[id];
+    return _extends({}, input, {
+        nodes
     });
 }
 /**
@@ -5197,7 +5513,8 @@ function slugKey(slug) {
  */ export const AI_FREE_PAGE_WORST_CASE_CREDITS = {
     plan: 83,
     layout: 64,
-    firstSection: 44,
+    // 44 until AGL-4092, whose rule 14 every section pass's cached prefix carries.
+    firstSection: 45,
     laterSection: 20,
     // A page's listing, on the fast tier at the platform's markup since
     // AGL-3781 (3 credits at Claude Haiku 4.5's cost before).