@aglyn/plugins-ai 1.0.0-beta.260 → 1.0.0-beta.262

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

@@ -642,6 +642,15 @@ const COLOR_KEYWORDS = new Set([
 const LITERAL_COLOR = /#[0-9a-f]{3,8}\b|\b(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\s*\(|\b(?:black|white|red|green|blue|yellow|orange|purple|pink|gray|grey|brown|cyan|magenta|navy|teal|maroon|olive|lime|aqua|silver|gold|indigo|violet|beige|coral|crimson|salmon|tomato|turquoise|khaki|lavender|ivory|azure)\b/i;
 const LENGTH_WITH_UNIT = /-?\d*\.?\d+\s*(?:px|rem|em|pt|vh|vw|ch)\b/i;
 const paletteTokens = new Set(AI_SX_TOKENS.palette);
+/**
+ * A color written as a value — a hex code or a color function — and never a
+ * color WORD. Plan prose names things in words: a photographer's "Blue Ridge
+ * elopements" or "Black and white portraits" is a place and a style, not a
+ * color, and the live 2026-10-16 guided start was refused for it (AGL-3864).
+ */ const LITERAL_COLOR_VALUE = /#[0-9a-f]{3,8}\b|\b(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\s*\(/i;
+/** Whether plan prose writes a color by value: a hex code or a color function. */ function proseHasLiteralColor(value) {
+    return typeof value === 'string' && LITERAL_COLOR_VALUE.test(value);
+}
 /** Whether a value names a color by value rather than by theme token. */ function hasLiteralColor(value) {
     if (typeof value !== 'string') return false;
     const parts = value.trim().split(/\s+/).filter((part)=>!paletteTokens.has(part) && !COLOR_KEYWORDS.has(part.toLowerCase()));
@@ -3892,6 +3901,53 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
         screens
     }) : plan;
 }
+/**
+ * References to nothing at all are taken out before the rules read the plan
+ * (AGL-3845), where each has one reading. The live Free candle-shop start of
+ * 2026-10-16, on an empty site, reused a layout `laySite` and duplicated a
+ * page `scrStarter` the site does not have, and wrote what each section
+ * shows into its uses ("hero", "product grid", "help text"). It was refused
+ * for the unknown records, and the Free wall's trim, which never takes a
+ * section that places something, could take none of them.
+ *
+ * - A reuse of a record the site does not have is dropped, and a page laid
+ *   out in it names no layout, for the layouts settle to place.
+ * - A page duplicated from a page the site does not have starts fresh.
+ * - A section's use that names no record the site has and no creation of the
+ *   plan is a description, not a reference, and comes out.
+ *
+ * Runs after `aiSettlePlanRefs`, so a creation spelled another way is
+ * already pointed at, never dropped.
+ */ export function aiSettlePlanUnknownIds(plan, inventory) {
+    const kinds = inventoryKinds(inventory);
+    const reuse = plan.reuse.filter((entry)=>entry.kind === 'theme' || kinds.get(entry.id) === entry.kind);
+    const dropped = new Set(plan.reuse.filter((entry)=>!reuse.includes(entry)).map((entry)=>entry.id));
+    const names = (ref)=>!!ref && (kinds.has(ref) || !!aiPlanCreateFor(plan, ref) || !!aiPlanItemFor(plan, ref) || isAiPlanNewRef(ref) && !dropped.has(ref));
+    let changed = reuse.length !== plan.reuse.length;
+    const screens = plan.screens.map((screen)=>{
+        const layout = screen.layout && dropped.has(screen.layout) ? null : screen.layout;
+        const duplicateOf = screen.duplicateOf && !kinds.has(screen.duplicateOf) ? null : screen.duplicateOf;
+        const sections = screen.sections.map((section)=>{
+            const uses = section.uses.filter(names);
+            return uses.length === section.uses.length ? section : _extends({}, section, {
+                uses
+            });
+        });
+        if (layout === screen.layout && duplicateOf === screen.duplicateOf && sections.every((one, index)=>one === screen.sections[index])) {
+            return screen;
+        }
+        changed = true;
+        return _extends({}, screen, {
+            layout,
+            duplicateOf,
+            sections
+        });
+    });
+    return changed ? _extends({}, plan, {
+        reuse,
+        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
@@ -4466,12 +4522,12 @@ const FORM_SECTION_NAME = /\bform\b|\bsign[- ]?up\b|\bsubscribe\b|\bnewsletter\b
     const paths = [];
     plan.create.forEach((entry, index)=>{
         if (entry.kind === 'theme-change') return;
-        if (hasLiteralColor(entry.why) || entry.fields.some(hasLiteralColor)) {
+        if (proseHasLiteralColor(entry.why) || entry.fields.some(proseHasLiteralColor)) {
             paths.push(`create[${index}]`);
         }
     });
     for (const { section, path } of sectionPaths(plan)){
-        if (hasLiteralColor(section.name)) paths.push(path);
+        if (proseHasLiteralColor(section.name)) paths.push(path);
     }
     return paths.length ? [
         {
@@ -4560,10 +4616,94 @@ const REUSE_BEFORE_CREATE_KINDS = new Set([
  * a component. Only the message reads it; the reference is refused whatever
  * it was meant to be.
  */ function undeclaredPlacementKind(name, section, plan, kinds) {
-    if (FORM_SECTION_NAME.test(name)) return 'form';
+    if (readsAsForm(name)) return 'form';
     const placesForm = section.uses.some((ref)=>refKind(ref, plan, kinds) === 'form');
     return FORM_SECTION_NAME.test(section.name) && !placesForm ? 'form' : 'component';
 }
+/** A creation's name in words: `contactForm` → "contact Form", so `\\bform\\b` can read it. */ function nameInWords(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[-_]+/g, ' ').trim();
+}
+/** Whether a creation's name, camelCase or not, names a form. */ function readsAsForm(name) {
+    return FORM_SECTION_NAME.test(nameInWords(name));
+}
+const NEWSLETTER_NAME = /\bnewsletter\b|\bsubscribe\b|\bsign[- ]?up\b/i;
+/**
+ * A section that places a creation the plan never declares is settled
+ * before the rules read the plan, where it has one answer (AGL-3845). The
+ * live candle-shop start of 2026-10-16 placed `new:contactForm` in its
+ * "Care, shipping and contact" section on both answers and stopped needing
+ * input: the camelCase name read as a component, which a site start may not
+ * make, and the refusal itself said to take it out.
+ *
+ * - A name that reads as a form, where this job may make one more form, is
+ *   declared as one: a newsletter's takes an email, any other the contact
+ *   form's fields, named in words ("Contact form") with the reference
+ *   pointed at it.
+ * - Anything else this job could not make one more of is taken out of the
+ *   section's uses, and the section is drawn on the page — unless the
+ *   section itself is the form ("consultation request form"): without it
+ *   the section has no purpose, and what to put there instead is the
+ *   rule's to ask.
+ * - A component the job could declare is left for the rule to ask about:
+ *   what it should be has more than one answer.
+ */ export function aiSettlePlanUndeclaredUses(plan, inventory, capabilities = null) {
+    if (!capabilities) return plan;
+    const kinds = inventoryKinds(inventory);
+    let next = plan;
+    const repoint = new Map();
+    const drop = new Set();
+    for (const ref of aiPlanUndeclaredRefs(plan)){
+        if (ref.field !== 'uses') continue;
+        const key = ref.name.toLowerCase();
+        if (repoint.has(key) || drop.has(ref.path)) continue;
+        const section = plan.screens[ref.screenIndex].sections[ref.sectionIndex];
+        const kind = undeclaredPlacementKind(ref.name, section, next, kinds);
+        if (kind === 'form' && readsAsForm(ref.name) && !aiPlanUncreatableKind(next, 'form', capabilities)) {
+            const words = nameInWords(ref.name).toLowerCase();
+            const name = `${words.charAt(0).toUpperCase()}${words.slice(1)}`;
+            repoint.set(key, `new:${name}`);
+            if (!aiPlanCreateFor(next, `new:${name}`)) {
+                next = _extends({}, next, {
+                    create: [
+                        ...next.create,
+                        {
+                            kind: 'form',
+                            name,
+                            why: AI_PLAN_SETTLED_FORM.why,
+                            duplicateOf: null,
+                            fields: NEWSLETTER_NAME.test(words) ? [
+                                'email'
+                            ] : [
+                                ...AI_PLAN_SETTLED_FORM.fields
+                            ]
+                        }
+                    ]
+                });
+            }
+        } else if (!FORM_SECTION_NAME.test(section.name) && aiPlanUncreatableKind(next, kind, capabilities)) {
+            drop.add(ref.path);
+        }
+    }
+    if (!repoint.size && !drop.size) return plan;
+    const undeclaredName = (ref)=>isAiPlanNewRef(ref) && !aiPlanCreateFor(plan, ref) && !aiPlanItemFor(plan, ref) ? ref.slice('new:'.length).trim().toLowerCase() : null;
+    return _extends({}, next, {
+        screens: next.screens.map((screen, screenIndex)=>_extends({}, screen, {
+                sections: screen.sections.map((section, sectionIndex)=>{
+                    const uses = section.uses.flatMap((ref, useIndex)=>{
+                        var _repoint_get;
+                        if (drop.has(`screens[${screenIndex}].sections[${sectionIndex}].uses[${useIndex}]`)) return [];
+                        const name = undeclaredName(ref);
+                        return [
+                            name !== null ? (_repoint_get = repoint.get(name)) != null ? _repoint_get : ref : ref
+                        ];
+                    });
+                    return uses.length === section.uses.length && uses.every((ref, index)=>ref === section.uses[index]) ? section : _extends({}, section, {
+                        uses
+                    });
+                })
+            }))
+    });
+}
 /**
  * Rule 7 (plan): what a plan places, it reuses or it creates (AGL-3040). The
  * doctrine has a plan refer to what it creates as new:<name>, so a reference
@@ -4635,6 +4775,11 @@ const REUSE_BEFORE_CREATE_KINDS = new Set([
             ].includes(String(refKind(ref, plan, kinds))));
         if (bindsData) continue;
         if (section.items >= AI_TYPED_LIST_MIN_ITEMS) typed.push(path);
+        // A form section COLLECTS what its dataset holds; it never copies it
+        // (AGL-3864). A workspace whose other site made a "Consultation
+        // requests" dataset refused a new law firm's "Consultation requests" form.
+        const collects = FORM_SECTION_NAME.test(section.name) || section.uses.some((ref)=>refKind(ref, plan, kinds) === 'form');
+        if (collects) continue;
         const match = data.find((row)=>aiNamesMatch(row.name, section.name));
         if (match) unbound.push({
             path,