@aglyn/plugins-ai 1.0.0-beta.244 → 1.0.0-beta.246

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

@@ -26,6 +26,8 @@ import { renderEmailHtml } from "@aglyn/shared-util-email/email-render";
 import { AI_BUILD_PLAN_CREATION_NOUNS, AI_BUILD_PLAN_EMBED_HOST_NAMES, AI_BUILD_PLAN_LIMITS, AI_PLAN_ASKS_FOR_VIDEO, aiEmbedHostOf, aiEmbedVideoKey, AI_PLAN_DATASET_ITEM_OP, aiPlanCreateFor, aiPlanFormDatasetNames, 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 { 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_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, AI_TEXT_LIMITS, isHeadlineVariant } from "./ai-palette.js";
@@ -3769,6 +3771,37 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
             }))
     });
 }
+/**
+ * A page section that is a layout region — a header, navigation or footer,
+ * read by the name rule 2's `plan-layout-region-section` reads — is taken off
+ * the page before the rules read the plan (AGL-3750). The region is already
+ * the layout's, so the rule's own answer, "take the section off the page", is
+ * the only one: a live Free start of 2026-10-12 (a bakery that sells cakes to
+ * order) planned a Header and a Footer on its pages three times and stopped.
+ *
+ * Only a section that places nothing, or nothing but a layout (which rule 2
+ * refuses placing as well), is taken off: one that places a form or a
+ * component may be a band misnamed, so the rule still asks. A page whose
+ * every section is a region keeps them all, and is re-asked as before, since
+ * a page of no sections has no answer here. A home this leaves under its
+ * fewest sections, or a Free plan still past its wall, is the existing
+ * checks' to settle or refuse.
+ */ export function aiSettlePlanLayoutRegionSections(plan, inventory) {
+    const kinds = inventoryKinds(inventory);
+    const removable = (section)=>LAYOUT_REGION_NAME.test(section.name) && section.uses.every((ref)=>refKind(ref, plan, kinds) === 'layout');
+    let changed = false;
+    const screens = plan.screens.map((screen)=>{
+        const kept = screen.sections.filter((section)=>!removable(section));
+        if (kept.length === screen.sections.length || !kept.length) return screen;
+        changed = true;
+        return _extends({}, screen, {
+            sections: kept
+        });
+    });
+    return changed ? _extends({}, plan, {
+        screens
+    }) : plan;
+}
 /** Every saved form a plan could place, the plan's own creations first. */ function planFormChoices(plan, inventory) {
     var _ref;
     return [
@@ -4419,6 +4452,135 @@ function slugKey(slug) {
     const needs = !((_ref = inventory == null ? void 0 : inventory.layouts.length) != null ? _ref : 0) && capabilities.create.layout.allowed ? 1 : 0;
     return Math.max(creates, needs);
 }
+/** The Free wall a plan is held to, or null where the job is not on the Free taste. */ function freePlanWall(plan, inventory, capabilities) {
+    if (!(capabilities == null ? void 0 : capabilities.freeTaste)) return null;
+    const asked = plan.screens.reduce((sum, screen)=>sum + screen.sections.length, 0);
+    const layouts = freePlanLayouts(plan, inventory, capabilities);
+    const pages = Math.max(plan.screens.length, 1);
+    // A Free site scaffold (AGL-3594) is held to its page cap first, and then to
+    // what a SITE plan's worst case leaves for sections, with room for a retry.
+    const sitePages = capabilities.freeSitePages;
+    const overPages = sitePages !== undefined && plan.screens.length > sitePages;
+    // 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,
+        forms: Math.max(0, forms)
+    }, FREE_AI_TASTE_CREDITS_PER_MONTH) : aiFreePageSectionsWithin({
+        layouts,
+        pages
+    });
+    // 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;
+    return {
+        asked,
+        fits,
+        layouts,
+        pages,
+        sitePages,
+        overPages,
+        homeMin
+    };
+}
+/**
+ * The most sections past the Free wall a plan is trimmed by rather than
+ * re-asked (AGL-3737). The live candle-shop start of 2026-10-12 planned 9
+ * sections against a wall of 8 on all three answers, each with a home of 7:
+ * the model reaching for the budget the site redo names ("plan 7 to 8") and
+ * landing one band past it, which no re-ask cured. Within two, the plan's
+ * shape is right and only a band or two the brief needs least is extra, so
+ * taking those from the end loses nothing the plan depends on. Further over,
+ * the shape itself is off — a list planned as sections, a page the wall
+ * cannot pay for — and cutting more would drop content the model meant, so
+ * that plan is still re-asked.
+ */ export const AI_FREE_WALL_SETTLE_MAX_OVER = 2;
+/** A section through which a visitor reaches the owner: contact, a visit, a booking. */ const REACH_SECTION_NAME = /\b(?:contact|get in touch|visit(?: us)?|find us|locations?|hours|book(?:ing)?|reserve|reservations?)\b/i;
+/**
+ * Whether the Free wall's trim keeps a section of a page (AGL-3737): the
+ * page's opening, any section that places something (a dataset it lists, a
+ * form, a component — dropping it would leave a creation unplaced), one that
+ * collects answers or says how to reach the owner, and a storefront's
+ * listing parts — the bestsellers, the collections, the sign-up, and a Shop
+ * page's product grid.
+ */ function freeWallKeeps(screen, index) {
+    const section = screen.sections[index];
+    if (index === 0 || section.uses.length > 0) return true;
+    if (FORM_SECTION_NAME.test(section.name) || REACH_SECTION_NAME.test(section.name)) return true;
+    if (aiStorefrontSays('featured', section.name) || aiStorefrontSays('collections', section.name) || aiStorefrontSays('signup', section.name)) {
+        return true;
+    }
+    return aiLayoutIsShopPage(screen) && aiLayoutShopGridSection(screen.sections) === index;
+}
+/**
+ * A Free plan a section or two past the wall is trimmed to fit before the
+ * rules read the plan (AGL-3737), rather than re-asked: which sections go has
+ * one answer, so the re-ask only costs the member a stopped start. The live
+ * candle-shop start of 2026-10-12 asked for a home of 7 and a second page of
+ * 2 against a wall of 8, three answers running, and stopped needing input.
+ *
+ * One section goes at a time, the last of its page that `freeWallKeeps`
+ * does not hold, from the page furthest past its share: the home at / past
+ * its fewest (`aiSiteHomeMinSections`, five on a site start whose wall pays
+ * for a full home), any other page past two; on a tie, the longer page, then
+ * the home. No home goes under its fewest and no page under one section. The
+ * shares are what a site start is told to plan (a home of five or six, the
+ * other page two or three): the candle shop's 7 + 2 becomes 6 + 2, never
+ * 7 + 1, and the recorded yoga answer's 6 + 4 becomes 5 + 3, the shape its
+ * own redo chose.
+ *
+ * A plan more than `AI_FREE_WALL_SETTLE_MAX_OVER` past the wall, a site
+ * start past its page cap, a plan with a list split into sections, and a
+ * plan the trim cannot fit without a section it keeps are returned
+ * unchanged, for the wall to re-ask.
+ */ export function aiSettlePlanFreeWall(plan, inventory, capabilities = null) {
+    const wall = freePlanWall(plan, inventory, capabilities);
+    if (!wall || wall.overPages) return plan;
+    const over = wall.asked - wall.fits;
+    if (over <= 0 || over > AI_FREE_WALL_SETTLE_MAX_OVER) return plan;
+    // A list split into sections is joined by its re-ask, which frees the room;
+    // a trim would cut one of its items and hide the split from the rule.
+    if (detectPlanSplitLists(plan, inventory, capabilities).length) return plan;
+    const kept = plan.screens.map((screen)=>screen.sections.map((section, index)=>({
+                section,
+                index
+            })));
+    const home = plan.screens.findIndex(aiSitePlanIsHome);
+    const floor = (screenIndex)=>screenIndex === home ? Math.max(wall.homeMin, 1) : 1;
+    const target = (screenIndex)=>screenIndex === home ? Math.max(wall.homeMin, 1) : 2;
+    // The last section of a page the trim may take, or -1.
+    const last = (screenIndex)=>{
+        const entries = kept[screenIndex];
+        if (entries.length <= floor(screenIndex)) return -1;
+        for(let at = entries.length - 1; at > 0; at -= 1){
+            if (!freeWallKeeps(plan.screens[screenIndex], entries[at].index)) return at;
+        }
+        return -1;
+    };
+    for(let left = over; left > 0; left -= 1){
+        let pick = -1;
+        for(let index = 0; index < kept.length; index += 1){
+            if (last(index) === -1) continue;
+            const room = kept[index].length - target(index);
+            const best = pick === -1 ? null : kept[pick].length - target(pick);
+            if (best === null || room > best || room === best && (kept[index].length > kept[pick].length || kept[index].length === kept[pick].length && index === home)) {
+                pick = index;
+            }
+        }
+        if (pick === -1) return plan;
+        kept[pick].splice(last(pick), 1);
+    }
+    return _extends({}, plan, {
+        screens: plan.screens.map((screen, index)=>kept[index].length === screen.sections.length ? screen : _extends({}, screen, {
+                sections: kept[index].map((entry)=>entry.section)
+            }))
+    });
+}
 /**
  * The Free wall (plan): a plan asks for no more sections than the Free taste
  * pays for at its worst beside what the job builds first (AGL-3070). A live
@@ -4429,14 +4591,10 @@ function slugKey(slug) {
  * proven with, so no plan the proof admits is refused. It is no building rule,
  * so it names none.
  */ export function detectPlanOverFreeWall(plan, inventory, capabilities) {
-    if (!(capabilities == null ? void 0 : capabilities.freeTaste)) return [];
-    const asked = plan.screens.reduce((sum, screen)=>sum + screen.sections.length, 0);
-    const layouts = freePlanLayouts(plan, inventory, capabilities);
-    const pages = Math.max(plan.screens.length, 1);
-    // A Free site scaffold (AGL-3594) is held to its page cap first, and then to
-    // what a SITE plan's worst case leaves for sections, with room for a retry.
-    const sitePages = capabilities.freeSitePages;
-    if (sitePages !== undefined && plan.screens.length > sitePages) {
+    const wall = freePlanWall(plan, inventory, capabilities);
+    if (!wall) return [];
+    const { asked, layouts, pages, sitePages, fits, homeMin } = wall;
+    if (sitePages !== undefined && wall.overPages) {
         return [
             {
                 rule: null,
@@ -4448,26 +4606,9 @@ 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,
-        forms: Math.max(0, forms)
-    }, FREE_AI_TASTE_CREDITS_PER_MONTH) : aiFreePageSectionsWithin({
-        layouts,
-        pages
-    });
     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.