@aglyn/plugins-ai 1.0.0-beta.236 → 1.0.0-beta.238

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

@@ -23,7 +23,7 @@ import { FREE_AI_TASTE_CREDITS_PER_MONTH } from "../plan-entitlements.js";
 import { REUSABLE_INSTANCE_COMPONENT_ID, REUSABLE_INSTANCE_PROP_VALUES_KEY } from "@aglyn/aglyn/app-utils/reusable-component-keys";
 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 { AI_BUILD_PLAN_CREATION_NOUNS, AI_BUILD_PLAN_EMBED_HOST_NAMES, AI_BUILD_PLAN_LIMITS, AI_PLAN_ASKS_FOR_VIDEO, aiEmbedHostOf, aiEmbedVideoKey, aiPlanCreateFor, aiPlanItemFor, aiPlanSlugKey, aiPlanUndeclaredRefs, isAiPlanNewRef } from "../model/ai-build-plan.js";
 import { aiCreationNoun, aiPlanCanPlaceForm, aiPlanUncreatable, aiPlanUncreatableKind } from "../model/ai-plan-capabilities.js";
 import { aiFreeSiteSectionsWithin, aiSiteHomeMinSections, aiSitePlanIsHome } from "../model/ai-site-job.js";
 import { AI_INSTANCE_REF_PROP, validateAiNodeTree } from "./ai-node-tree.js";
@@ -279,12 +279,15 @@ function listNames(ids, tree) {
     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.
+   * in a cell of a grid — or that cell, holding only the card. A storefront's
+   * icon column (AGL-3676), a Stack that opens with its library icon, is the
+   * compiler's the same way: no model writes an Icon on a page.
    */ 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 opens = first === undefined ? undefined : (_tree_nodes_first = tree.nodes[first]) == null ? void 0 : _tree_nodes_first.componentId;
+        return (node == null ? void 0 : node.componentId) === 'muiStack' && (opens === 'image' || opens === 'icon');
     };
     const pictureCard = (id)=>{
         var _node_props, _node_nodes, _index_visits_find, _tree_nodes_parentId;
@@ -2351,6 +2354,13 @@ const DUPLICATE_SX_MIN_NODES = 4;
     const key = aiEmbedVideoKey(url);
     return key && planned.some((embed)=>embed.url && aiEmbedVideoKey(embed.url) === key) ? 'planned' : 'unplanned-link';
 }
+/**
+ * Containers whose empty state is something they draw themselves, so an empty
+ * one is a placement and not a gap (AGL-3716): the Music player, placed with
+ * no tracks, asks its owner to add their own; a model never fills it.
+ */ const OWNS_ITS_EMPTY_STATE = new Set([
+    'musicPlayer'
+]);
 /**
  * Rule 16. The flattest tree that renders the design: no container that
  * wraps one other container and adds nothing, no empty containers, no inline
@@ -2379,7 +2389,9 @@ const DUPLICATE_SX_MIN_NODES = 4;
             wrappers.push(id);
         }
         const boundForm = node.componentId === 'form' && typeof ((_node_props1 = node.props) == null ? void 0 : _node_props1['formId']) === 'string';
-        if ((entry == null ? void 0 : entry.acceptsChildren) && !children.length && !boundForm) empty.push(id);
+        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 (node.componentId === 'image') {
             var _node_props6;
@@ -3277,11 +3289,18 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
  * creation before the rules read the plan, when exactly one creation matches
  * it with case, spaces and punctuation ignored. Two that match, or none, are
  * left for the rules to ask about.
- */ export function aiSettlePlanRefs(plan) {
+ *
+ * So is a creation named without its prefix — `Contact form` in a section's
+ * uses for the "Contact form" the plan creates — where the name is no record
+ * the site has (AGL-3660). A re-asked plan told to place its form "by id"
+ * can answer with the form's bare name, which is no reference at all.
+ */ export function aiSettlePlanRefs(plan, inventory = null) {
     if (!plan.create.length) return plan;
+    const kinds = inventoryKinds(inventory);
     const resolve = (ref)=>{
-        if (!isAiPlanNewRef(ref) || aiPlanCreateFor(plan, ref)) return ref;
-        const key = creationKey(ref.slice('new:'.length));
+        if (!ref || kinds.has(ref) || aiPlanCreateFor(plan, ref)) return ref;
+        const key = creationKey(isAiPlanNewRef(ref) ? ref.slice('new:'.length) : ref);
+        if (!key) return ref;
         const matches = plan.create.filter((entry)=>creationKey(entry.name) === key);
         return matches.length === 1 ? `new:${matches[0].name}` : ref;
     };
@@ -3357,6 +3376,140 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
             }))
     });
 }
+/** Every saved form a plan could place, the plan's own creations first. */ function planFormChoices(plan, inventory) {
+    var _ref;
+    return [
+        ...plan.create.filter((entry)=>entry.kind === 'form').map((entry)=>({
+                ref: `new:${entry.name}`,
+                name: entry.name,
+                created: true
+            })),
+        ...((_ref = inventory == null ? void 0 : inventory.forms) != null ? _ref : []).map((form)=>({
+                ref: form.id,
+                name: form.name,
+                created: false
+            }))
+    ];
+}
+/** The form a plan's own words would name for a section's reference, so placements count alike. */ function formChoiceKey(ref, plan) {
+    const created = isAiPlanNewRef(ref) ? aiPlanCreateFor(plan, ref) : undefined;
+    return created ? `new:${created.name}` : ref;
+}
+/**
+ * The form a section that collects answers places: the one whose name shares
+ * the most words with the section's ("Commission inquiry" → "Commission
+ * inquiry form"), then the one the plan already places most, then the plan's
+ * own creation over a form the site has. `null` when there is none.
+ */ function bestPlanForm(section, choices, placed) {
+    var _ranked_;
+    const words = new Set(nameTokens(section.name).filter((word)=>word !== 'form'));
+    const score = (choice)=>nameTokens(choice.name).filter((word)=>word !== 'form' && words.has(word)).length;
+    const ranked = [
+        ...choices
+    ].sort((a, b)=>{
+        var _placed_get, _placed_get1;
+        return score(b) - score(a) || ((_placed_get = placed.get(b.ref)) != null ? _placed_get : 0) - ((_placed_get1 = placed.get(a.ref)) != null ? _placed_get1 : 0) || Number(b.created) - Number(a.created);
+    });
+    return (_ranked_ = ranked[0]) != null ? _ranked_ : null;
+}
+/** The contact form a plan is given when a section collects answers and the plan makes no form. */ export const AI_PLAN_SETTLED_FORM = {
+    name: 'Contact form',
+    why: 'Visitors need a way to reach the owner, and the site has no saved form for it.',
+    fields: [
+        'name',
+        'email',
+        'message'
+    ]
+};
+/**
+ * A section that collects answers and places no saved form is given one
+ * before the rules read the plan (AGL-3660), rather than failing the build.
+ * A production guided start for a ceramic artist's portfolio (2026-10-09,
+ * five pages, 94 credits refunded) planned a section that asks for
+ * commissions on its work page without placing the contact form the plan
+ * made for its Contact page; the answer and its re-ask both did, and rule 3
+ * failed the whole site for one section.
+ *
+ * The section places, in order of preference:
+ * 1. the form whose name best matches it, among those the plan creates and
+ *    the site has, preferring one the plan already places — so a guided
+ *    start, which makes one form, places that same form again rather than a
+ *    second one;
+ * 2. where there is no form at all and this job may create one, a form the
+ *    plan now creates: named for the `new:` reference the section already
+ *    holds when it names a form it never declared, the contact form
+ *    otherwise.
+ *
+ * Nothing is taken out of the plan: the section keeps its name, its other
+ * uses and its items. Where the site has no form and the job may create none,
+ * rule 3 asks for nothing (AGL-3596), and neither does this. A section whose
+ * uses are already full is left for the rule to ask about.
+ */ export function aiSettlePlanForms(plan, inventory, capabilities = null) {
+    if (!aiPlanCanPlaceForm(inventory, capabilities)) return plan;
+    const kinds = inventoryKinds(inventory);
+    const unbound = (current)=>sectionPaths(current).filter(({ section })=>FORM_SECTION_NAME.test(section.name) && section.uses.length < AI_BUILD_PLAN_LIMITS.uses && !section.uses.some((ref)=>refKind(ref, current, kinds) === 'form'));
+    const first = unbound(plan);
+    if (!first.length) return plan;
+    let next = plan;
+    if (!planFormChoices(next, inventory).length) {
+        if (capabilities && !capabilities.create.form.allowed) return plan;
+        // A form the section already names and the plan never declared is the form it meant.
+        const named = first.flatMap(({ section })=>section.uses).find((ref)=>isAiPlanNewRef(ref) && !aiPlanCreateFor(next, ref) && !aiPlanItemFor(next, ref));
+        const taken = new Set(next.create.map((entry)=>entry.name.toLowerCase()));
+        const name = named ? named.slice('new:'.length).trim() : taken.has(AI_PLAN_SETTLED_FORM.name.toLowerCase()) ? 'Get in touch form' : AI_PLAN_SETTLED_FORM.name;
+        next = _extends({}, next, {
+            create: [
+                ...next.create,
+                {
+                    kind: 'form',
+                    name,
+                    why: AI_PLAN_SETTLED_FORM.why,
+                    duplicateOf: null,
+                    fields: [
+                        ...AI_PLAN_SETTLED_FORM.fields
+                    ]
+                }
+            ]
+        });
+    }
+    const choices = planFormChoices(next, inventory);
+    const placed = new Map();
+    for (const { section } of sectionPaths(next)){
+        for (const ref of section.uses){
+            var _placed_get;
+            if (refKind(ref, next, kinds) !== 'form') continue;
+            const key = formChoiceKey(ref, next);
+            placed.set(key, ((_placed_get = placed.get(key)) != null ? _placed_get : 0) + 1);
+        }
+    }
+    const settle = new Map();
+    for (const { section, path } of unbound(next)){
+        const form = bestPlanForm(section, choices, placed);
+        if (form) settle.set(path, form.ref);
+    }
+    if (!settle.size) return next;
+    return _extends({}, next, {
+        screens: next.screens.map((screen, screenIndex)=>_extends({}, screen, {
+                sections: screen.sections.map((section, sectionIndex)=>{
+                    const ref = settle.get(`screens[${screenIndex}].sections[${sectionIndex}]`);
+                    if (!ref) return section;
+                    // The undeclared reference the form was named for now names it; any other stays.
+                    const uses = section.uses.some((use)=>formChoiceKey(use, next) === ref) ? section.uses : [
+                        ...section.uses,
+                        ref
+                    ];
+                    return _extends({}, section, {
+                        uses
+                    });
+                })
+            }))
+    });
+}
+/** The forms a section that collects answers can place, as the re-ask names them. */ function planFormChoicesText(plan, inventory) {
+    const choices = planFormChoices(plan, inventory);
+    if (!choices.length) return 'Plan one in create as a form, and put new:<its name> in the section\'s uses.';
+    return `Put one of these in the section's uses: ${choices.map((choice)=>choice.created ? choice.ref : `${choice.ref} (${choice.name})`).join(', ')}.`;
+}
 /**
  * Rule 2 (plan): every screen declares a layout, no section is a copy of a
  * layout region, and no section places a layout, which frames a whole screen
@@ -3417,6 +3570,7 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
             rule: 3,
             code: 'plan-form-not-placed',
             message: 'A section collects answers without a form. Reuse a form from the Forms page, or plan one there, and place it by id.',
+            detail: planFormChoicesText(plan, inventory),
             paths: unbound.map((entry)=>entry.path)
         }
     ] : [];