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

package/src/lib/runtime/ai-doctrine-validators.d.ts

@@ -754,6 +754,46 @@ export declare function detectPlanSplitLists(plan: AiBuildPlan, inventory: AiSit
  * can answer with the form's bare name, which is no reference at all.
  */
 export declare function aiSettlePlanRefs(plan: AiBuildPlan, inventory?: AiSiteInventory | null): AiBuildPlan;
+/**
+ * What customers say, which no dataset of the site's holds: a review, a
+ * testimonial, a rating, a quote (AGL-3616). A job never writes them for the
+ * people who did not, so a dataset of them is one nothing can seed.
+ */
+export declare const AI_DATASET_SAID_NAME: RegExp;
+/**
+ * A plan that creates more datasets than this job may make is settled in
+ * code, never re-asked (AGL-3616). The live eval of 2026-10-10 refused a
+ * dental practice's plan four times over for a fourth dataset, and a food
+ * bank's re-ask for one broke a layout rule its first answer had kept.
+ *
+ * A dataset of what customers say (`AI_DATASET_SAID_NAME`, in its name or a
+ * field) is let go first, whatever the cap: both of those plans made one of
+ * testimonials, which nothing may seed.
+ *
+ * The datasets kept are the most useful: the ones the most sections list,
+ * a record template counting double, plan order breaking ties. Each one let
+ * go leaves the plan whole — its `new:` reference comes off every section,
+ * a record template of it becomes a page of its own, and a section that
+ * listed it shows fewer items than rule 8 binds, so its items are written
+ * out on the page. Where the job may create no dataset at all, rule 7 still
+ * asks, as it does for any creation.
+ */
+export declare function aiSettlePlanDatasets(plan: AiBuildPlan, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
+/**
+ * A form's dataset, settled in code before the rules read the plan
+ * (AGL-3616, Zach 2026-10-10: Aglyn AI's forms write to its datasets).
+ *
+ *  - A `writesTo` that names nothing the form can write to comes off: a
+ *    `new:` of no dataset this plan creates, an id the inventory does not
+ *    hold, or a dataset this job may not create. The form is then the
+ *    form it always was, its submissions in the Inbox. A dataset the
+ *    inventory holds, named by its name rather than its id, is given its id.
+ *  - A dataset this plan creates for a form holds the people who send it:
+ *    no page lists it and none is its record template, so its `new:` comes
+ *    off every section and record that named it, and a section that listed
+ *    it shows fewer items than rule 8 binds.
+ */
+export declare function aiSettlePlanFormDatasets(plan: AiBuildPlan, inventory: AiSiteInventory | null, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
 /**
  * A page that names no layout, on a site where only one layout can frame it,
  * is put in that layout before the rules read the plan (2026-10-07). The

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_BUILD_PLAN_LIMITS, AI_PLAN_ASKS_FOR_VIDEO, aiEmbedHostOf, aiEmbedVideoKey, aiPlanCreateFor, aiPlanItemFor, 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, 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 { AI_INSTANCE_REF_PROP, validateAiNodeTree } from "./ai-node-tree.js";
@@ -3324,6 +3324,135 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
         screens
     }) : plan;
 }
+/**
+ * What customers say, which no dataset of the site's holds: a review, a
+ * testimonial, a rating, a quote (AGL-3616). A job never writes them for the
+ * people who did not, so a dataset of them is one nothing can seed.
+ */ export const AI_DATASET_SAID_NAME = /\b(reviews?|testimonials?|ratings?|quotes?|stars?|endorsements?)\b/i;
+/**
+ * A plan that creates more datasets than this job may make is settled in
+ * code, never re-asked (AGL-3616). The live eval of 2026-10-10 refused a
+ * dental practice's plan four times over for a fourth dataset, and a food
+ * bank's re-ask for one broke a layout rule its first answer had kept.
+ *
+ * A dataset of what customers say (`AI_DATASET_SAID_NAME`, in its name or a
+ * field) is let go first, whatever the cap: both of those plans made one of
+ * testimonials, which nothing may seed.
+ *
+ * The datasets kept are the most useful: the ones the most sections list,
+ * a record template counting double, plan order breaking ties. Each one let
+ * go leaves the plan whole — its `new:` reference comes off every section,
+ * a record template of it becomes a page of its own, and a section that
+ * listed it shows fewer items than rule 8 binds, so its items are written
+ * out on the page. Where the job may create no dataset at all, rule 7 still
+ * asks, as it does for any creation.
+ */ export function aiSettlePlanDatasets(plan, capabilities = null) {
+    var _ref, _entry_left;
+    const entry = capabilities == null ? void 0 : capabilities.create.dataset;
+    if (!(entry == null ? void 0 : entry.allowed)) return plan;
+    const cap = Math.min((_ref = capabilities == null ? void 0 : capabilities.datasetsMax) != null ? _ref : Infinity, (_entry_left = entry.left) != null ? _entry_left : Infinity);
+    const datasets = plan.create.filter((one)=>one.kind === 'dataset');
+    // A dataset a form writes to holds what visitors send (AGL-3616): its
+    // fields may well be a rating or a quote request, and nothing seeds it.
+    const forForms = aiPlanFormDatasetNames(plan);
+    const said = (one)=>!forForms.has(one.name.trim().toLowerCase()) && (AI_DATASET_SAID_NAME.test(one.name) || one.fields.some((field)=>AI_DATASET_SAID_NAME.test(field)));
+    if (!datasets.some(said) && (!Number.isFinite(cap) || datasets.length <= cap)) return plan;
+    const named = (ref, name)=>!!ref && isAiPlanNewRef(ref) && ref.slice('new:'.length).trim().toLowerCase() === name.trim().toLowerCase();
+    // A form's dataset counts as much as a record template: the form the
+    // person asked for is built around it.
+    const score = (name)=>(forForms.has(name.trim().toLowerCase()) ? 2 : 0) + plan.screens.reduce((total, screen)=>{
+            var _screen_record;
+            return total + (named((_screen_record = screen.record) == null ? void 0 : _screen_record.dataset, name) ? 2 : 0) + screen.sections.filter((section)=>section.uses.some((ref)=>named(ref, name))).length;
+        }, 0);
+    const ranked = datasets.filter((one)=>!said(one)).map((one, index)=>({
+            name: one.name,
+            index,
+            score: score(one.name)
+        })).sort((a, b)=>b.score - a.score || a.index - b.index);
+    const kept = new Set(ranked.slice(0, Math.max(0, cap)).map((one)=>one.name.trim().toLowerCase()));
+    const dropped = new Set(datasets.map((one)=>one.name.trim().toLowerCase()).filter((name)=>!kept.has(name)));
+    const isDropped = (ref)=>[
+            ...dropped
+        ].some((name)=>named(ref, name));
+    return _extends({}, plan, {
+        create: plan.create.filter((one)=>one.kind !== 'dataset' || !dropped.has(one.name.trim().toLowerCase()))// A form whose dataset was let go sends its submissions to the Inbox only.
+        .map((one)=>one.kind === 'form' && isDropped(one.writesTo) ? withoutWritesTo(one) : one),
+        screens: plan.screens.map((screen)=>_extends({}, screen, {
+                record: screen.record && isDropped(screen.record.dataset) ? null : screen.record,
+                sections: screen.sections.map((section)=>section.uses.some(isDropped) ? _extends({}, section, {
+                        uses: section.uses.filter((ref)=>!isDropped(ref)),
+                        items: Math.min(section.items, AI_TYPED_LIST_MIN_ITEMS - 1)
+                    }) : section)
+            }))
+    });
+}
+/** A creation with no `writesTo`, as a plan that never said one reads. */ function withoutWritesTo(creation) {
+    const rest = _extends({}, creation);
+    delete rest.writesTo;
+    return rest;
+}
+/**
+ * A form's dataset, settled in code before the rules read the plan
+ * (AGL-3616, Zach 2026-10-10: Aglyn AI's forms write to its datasets).
+ *
+ *  - A `writesTo` that names nothing the form can write to comes off: a
+ *    `new:` of no dataset this plan creates, an id the inventory does not
+ *    hold, or a dataset this job may not create. The form is then the
+ *    form it always was, its submissions in the Inbox. A dataset the
+ *    inventory holds, named by its name rather than its id, is given its id.
+ *  - A dataset this plan creates for a form holds the people who send it:
+ *    no page lists it and none is its record template, so its `new:` comes
+ *    off every section and record that named it, and a section that listed
+ *    it shows fewer items than rule 8 binds.
+ */ export function aiSettlePlanFormDatasets(plan, inventory, capabilities = null) {
+    var _ref;
+    if (!plan.create.some((one)=>one.kind === 'form' && one.writesTo)) return plan;
+    const held = (_ref = inventory == null ? void 0 : inventory.datasets) != null ? _ref : [];
+    const creatable = !capabilities || capabilities.create.dataset.allowed;
+    let changed = false;
+    const create = plan.create.map((one)=>{
+        if (one.kind !== 'form' || !one.writesTo) return one;
+        const ref = one.writesTo.trim();
+        if (isAiPlanNewRef(ref)) {
+            var _aiPlanCreateFor, _aiPlanItemFor;
+            if (creatable && ((_aiPlanCreateFor = aiPlanCreateFor(plan, ref)) == null ? void 0 : _aiPlanCreateFor.kind) === 'dataset') return one;
+            // A build's dataset item, which the data plugin's operation makes.
+            if (((_aiPlanItemFor = aiPlanItemFor(plan, ref)) == null ? void 0 : _aiPlanItemFor.op) === AI_PLAN_DATASET_ITEM_OP) return one;
+        } else {
+            if (held.some((row)=>row.id === ref)) return one;
+            const byName = held.find((row)=>aiNamesMatch(row.name, ref));
+            if (byName) {
+                changed = true;
+                return _extends({}, one, {
+                    writesTo: byName.id
+                });
+            }
+        }
+        changed = true;
+        return withoutWritesTo(one);
+    });
+    const settled = _extends({}, plan, {
+        create
+    });
+    const forForms = aiPlanFormDatasetNames(settled);
+    const listsOne = (ref)=>isAiPlanNewRef(ref) && forForms.has(ref.slice('new:'.length).trim().toLowerCase());
+    const screens = plan.screens.map((screen)=>{
+        const record = screen.record && listsOne(screen.record.dataset) ? null : screen.record;
+        const sections = screen.sections.map((section)=>section.uses.some(listsOne) ? _extends({}, section, {
+                uses: section.uses.filter((ref)=>!listsOne(ref)),
+                items: Math.min(section.items, AI_TYPED_LIST_MIN_ITEMS - 1)
+            }) : section);
+        if (record === screen.record && sections.every((section, index)=>section === screen.sections[index])) return screen;
+        changed = true;
+        return _extends({}, screen, {
+            record,
+            sections
+        });
+    });
+    return changed ? _extends({}, settled, {
+        screens
+    }) : plan;
+}
 /**
  * A page that names no layout, on a site where only one layout can frame it,
  * is put in that layout before the rules read the plan (2026-10-07). The