@aglyn/plugins-ai 1.0.0-beta.241 → 1.0.0-beta.243

package/src/lib/jobs/ai-layout-stock-photos.js

@@ -95,6 +95,28 @@ import { aiStorefrontSays } from "../layout-language/ai-layout-storefront.js";
  *    to its photographer. A copy that fails tries the slot's next accepted
  *    hit.
  *
+ * 6. **Fall back to the craft, never off it** (the beta.241 Saltmarsh Soap
+ *    Co start, a store "for handmade cold-process soap": its craft read as
+ *    nothing, its hero searched "shop" and took a florist's bouquet, and four
+ *    of five products took the starters' laptop desk and living room). A
+ *    business that is only a place takes its craft from what it is for
+ *    ("soap shop"); a hero names the craft itself ({@link AiStockSiteTerms.core});
+ *    a product, after its own searches, tries its head noun anywhere among
+ *    the tags, its gift wrapper with the craft and the craft's broad
+ *    searches, and then — a product or a hero only — reuses an on-topic photo
+ *    the job already shows rather than take a starter. Every slot of a
+ *    craft's site tries the craft's broad searches last.
+ * 7. **A product takes the surest photo, even a borrowed one** (the beta.242
+ *    Tidewater Soap Works start: a sauna for "Bath Gift Set", colognes for
+ *    "Natural Body Lotion", a bathroom shelf for "Soap Bar Trio" and a soap
+ *    dispenser for its starter size, while the collection tiles beside them
+ *    were good). A product's searches are ranked by how sure they are: its
+ *    own photo (the head noun or its kin among the first tags), then a photo
+ *    OF its category, new or one the job already shows, then a weak hit of
+ *    its own. No product shows a room or a scene, a fragrance bottle, or what
+ *    its kin shuns (a pump for a bar) unless it names it; "bath" in a bath
+ *    gift set is what the set is for; a size is never the product.
+ *
  * A slot nothing acceptable answered — the library down, refusing, or out
  * of time — is left `null` for the starter photos. A named object is never
  * given one while the library answers anything of the site's world: the
@@ -120,7 +142,8 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
 /**
  * Words that describe a picture's look, not what it shows, dropped from a
  * subject. A word that is as often a noun ("light", "set") is not one.
- */ const FILLER = words('beautiful beautifully stunning gorgeous lovely pretty elegant modern contemporary rustic cozy cosy warm cool ' + 'soft bright natural simple minimal minimalist delicate unique special artisan artisanal handmade ' + 'hand-made hand-thrown handthrown hand-crafted handcrafted crafted hand-built handbuilt hand-poured ' + 'hand-painted hand-dyed hand-stitched poured finished styled perfect wheel-thrown wheelthrown thrown ' + 'fresh clean calm serene quiet peaceful vibrant colorful colourful sunlit sunny golden glossy matte textured ' + 'close-up closeup up view views detail details detailed shot shots overhead flat lay flatlay flat-lay ' + 'top-down wide angle featuring featured displayed arranged sitting resting placed standing lined ' + 'single pair collection assortment selection group few various array range large tiny big little ' + 'tall short wide narrow everyday classic signature original favorite favourite bestselling best-selling ' + 'small-batch batch limited edition custom bespoke ' + 'white black grey gray beige cream ivory brown tan blue green red pink yellow orange purple speckled ' + 'gentle airy inviting welcoming cheerful happy smiling friendly');
+ */ const FILLER = words('beautiful beautifully stunning gorgeous lovely pretty elegant modern contemporary rustic cozy cosy warm cool ' + 'soft bright natural simple minimal minimalist delicate unique special artisan artisanal handmade ' + 'hand-made hand-thrown handthrown hand-crafted handcrafted crafted hand-built handbuilt hand-poured ' + 'hand-painted hand-dyed hand-stitched poured finished styled perfect wheel-thrown wheelthrown thrown ' + 'fresh clean calm serene quiet peaceful vibrant colorful colourful sunlit sunny golden glossy matte textured ' + 'close-up closeup up view views detail details detailed shot shots overhead flat lay flatlay flat-lay ' + 'top-down wide angle featuring featured displayed arranged sitting resting placed standing lined ' + 'single pair collection assortment selection group few various array range large tiny big little ' + 'tall short wide narrow everyday classic signature original favorite favourite bestselling best-selling ' + 'small-batch batch limited edition custom bespoke ' + // How a soap is made, never what it shows: "cold" and "process" named a supermarket fridge (Saltmarsh, 2026-10-10).
+'cold-process cold-processed hot-process hot-processed melt-and-pour ' + 'white black grey gray beige cream ivory brown tan blue green red pink yellow orange purple speckled ' + 'gentle airy inviting welcoming cheerful happy smiling friendly');
 /** The nouns that name a place of business, not its craft: "studio" in "ceramics studio". */ const VENUES = words('studio studios shop shops store stores boutique company co workshop gallery atelier agency brand practice ' + 'salon house collective lab market services service firm clinic center centre parlor parlour bar ' + 'class classes lessons school academy');
 /** The person who does the craft, not the craft: "artist" in "ceramic artist". */ const ROLES = words('artist artists maker makers artisan artisans owner owners founder founders creator creators');
 /** Words naming what kind of SITE it is, never what it shows: "portfolio" in "a portfolio for a ceramic artist". */ const SITE_KINDS = words('portfolio portfolios website websites site sites blog blogs online web webshop ecommerce e-commerce ' + 'landing personal homepage storefront');
@@ -136,6 +159,47 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
  * an empty frame on the page (the Juniper Clay hero), a template or a
  * graphic is not a photo of anything.
  */ const REJECTED_TAGS = words('mockup mock-up mock blank template templates clipart clip-art illustration vector logo icon ' + 'ai-generated generated render rendering 3d');
+/**
+ * Rooms and scenes, never a product (AGL-3660): the beta.242 Tidewater Soap
+ * Works start put a wooden sauna under "Bath Gift Set" and a bathroom shelf of
+ * baskets under "Soap Bar Trio". A product's hit whose first tags name one of
+ * these is turned down unless the product or the brief names it too.
+ */ const PRODUCT_SCENES = new Set([
+    'sauna',
+    'bathroom',
+    'bathtub',
+    'shower',
+    'toilet',
+    'sink',
+    'washbasin',
+    'faucet',
+    'tap',
+    'shelf',
+    'shelves',
+    'interior',
+    'bedroom',
+    'kitchen',
+    'room',
+    'livingroom',
+    'hotel',
+    'lobby'
+].map(aiStockStem));
+/**
+ * A fragrance's bottle, never a lotion, a cream or a soap (AGL-3660): the same
+ * start's "Natural Body Lotion" showed blue cologne bottles tagged "perfume,
+ * bottle, lotion". Turned down among a product's first tags unless the
+ * product or the brief is a fragrance.
+ */ const FRAGRANCE_BOTTLES = new Set([
+    'perfume',
+    'perfumes',
+    'perfumery',
+    'cologne',
+    'colognes',
+    'parfum',
+    'eau',
+    'atomizer',
+    'fragrance'
+].map(aiStockStem));
 /**
  * Topics a business's photos never carry unless its own words name them
  * (AGL-3660, the beta.239 Ember & Oak start, whose "Gifts for melt fans" tile
@@ -303,6 +367,7 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
     },
     {
         // Tobacco and drugs.
+        // "cbd" and "cannabinoid": a hemp cream tube was the next "body lotion" answer (Tidewater, 2026-10-11).
         words: [
             'cigarette',
             'smoking',
@@ -310,7 +375,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'cannabis',
             'marijuana',
             'drug',
-            'drugs'
+            'drugs',
+            'cbd',
+            'cannabinoid',
+            'thc'
         ],
         allow: [
             'dispensary',
@@ -469,6 +537,129 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'wax melt warmer',
             'scented wax cubes'
         ]
+    },
+    {
+        // A "bar" is a pub's before it is a soap's (the Saltmarsh "cold-process
+        // soap bar" search answered a pint of beer second): a soap bar is named
+        // by soap, and searched by it.
+        objects: [
+            'bar'
+        ],
+        within: [
+            'soap',
+            'soapmaker',
+            'skincare'
+        ],
+        qualifier: 'soap',
+        kin: [
+            'soap bar',
+            'soap bars',
+            'bar of soap',
+            'bars of soap',
+            'soap',
+            'soaps',
+            'handmade soap',
+            'soap block',
+            'soap cubes'
+        ],
+        queries: [
+            'soap bars',
+            'handmade soap bar'
+        ],
+        // A bar is never a pump or a liquid soap (the beta.242 Tidewater start).
+        shun: [
+            'pump',
+            'pumps',
+            'liquid',
+            'dispenser',
+            'dispensers'
+        ]
+    },
+    {
+        // "Bath" in "bath gift set", "bath bomb" or "bath salts" is what the
+        // products are for, never the room: the beta.242 Tidewater Soap Works
+        // start (2026-10-11) put a wooden sauna under "Bath Gift Set", its tags
+        // "sauna, steam, bath". A bath set is named by soap and bath products,
+        // and searched with soap.
+        objects: [
+            'bath'
+        ],
+        within: [
+            'soap',
+            'soapmaker',
+            'skincare',
+            'spa',
+            'cosmetic'
+        ],
+        qualifier: 'soap',
+        after: true,
+        kin: [
+            'soap',
+            'soaps',
+            'soap bar',
+            'soap bars',
+            'handmade soap',
+            'bath bomb',
+            'bath bombs',
+            'bath salt',
+            'bath salts',
+            'bath product',
+            'bath products',
+            'bath set',
+            'toiletries'
+        ],
+        queries: [
+            'soap gift set',
+            'bath products',
+            'bath bombs'
+        ],
+        shun: [
+            'pump',
+            'pumps',
+            'liquid',
+            'dispenser',
+            'dispensers'
+        ]
+    },
+    {
+        // A lotion is any cream for the skin; a perfume bottle tagged "lotion"
+        // is not one (the same start's "Natural Body Lotion" showed colognes).
+        objects: [
+            'lotion',
+            'moisturizer',
+            'moisturiser'
+        ],
+        within: [
+            'soap',
+            'soapmaker',
+            'skincare',
+            'lotion',
+            'cosmetic',
+            'beauty',
+            'spa'
+        ],
+        kin: [
+            'lotion',
+            'lotions',
+            'body lotion',
+            'hand lotion',
+            'cream',
+            'creams',
+            'hand cream',
+            'body cream',
+            'skin cream',
+            'face cream',
+            'cream jar',
+            'body butter',
+            'moisturizer',
+            'moisturiser'
+        ],
+        queries: [
+            'body lotion',
+            'hand cream',
+            'cream jar',
+            'moisturizer'
+        ]
     }
 ];
 /** An object's kin where the site or the subject is of its world, else `null`. */ function objectKin(object, world) {
@@ -595,21 +786,56 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'soapmaker',
             'skincare'
         ],
+        // Never "natural": a florist's bouquet tagged "natural" was the
+        // Saltmarsh Soap Co hero (2026-10-10).
         kin: [
             'soap',
             'skincare',
             'lotion',
+            'cream',
             'bath',
             'spa',
-            'natural',
             'cosmetic'
         ],
         broad: [
             'handmade soap',
             'natural skincare'
         ],
+        // "Soap making" is answered with soap bubbles; a bar is what a soapmaker makes.
         making: [
-            'soap making'
+            'soap making',
+            'handmade soap'
+        ],
+        // Soap bubbles, a dispenser and detergent are soap, never a soapmaker's:
+        // the same start's story band showed bubbles in flight.
+        rivals: {
+            words: [
+                'bubble',
+                'bubbles',
+                'soapy',
+                'dispenser',
+                'detergent',
+                'dishwashing',
+                'laundry'
+            ],
+            core: [
+                'bar',
+                'bars',
+                'handmade',
+                'homemade',
+                'loaf',
+                'lye',
+                'glycerin',
+                'skincare',
+                'lotion',
+                'cosmetic',
+                'spa',
+                'artisan'
+            ]
+        },
+        shun: [
+            'dispenser',
+            'dispensers'
         ]
     },
     {
@@ -837,10 +1063,11 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
     return craft ? aiStockStem(craft) : '';
 }
 /** The site's terms, read from its business type. */ export function aiStockSiteTerms(businessType) {
-    const business = aiStockBusinessWords(businessType);
-    const craft = aiStockCraftWords(business);
+    let business = aiStockBusinessWords(businessType);
+    let craft = aiStockCraftWords(business);
     const domain = new Set();
     /** The things it makes, by their head nouns. */ const made = new Set();
+    /** The last word of the first clause that names the world: "soap" of "for handmade cold-process soap". */ let firstWorld = '';
     let named = false;
     let making = false;
     for (const { opener, words: clause } of businessClauses(businessType)){
@@ -858,16 +1085,37 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         // A set or a gift is never a world: "gift" of "gift sets" is not one.
         const world = (making ? kept.slice(0, -1) : kept).filter((word)=>!WRAPPERS.has(word));
         for (const word of world)for (const stem of stemList(word))domain.add(stem);
+        const last = world[world.length - 1];
+        if (!firstWorld && last) firstWorld = aiStockStem(last);
         if (making) for (const word of kept.slice(-1))for (const stem of stemList(word))made.add(stem);
     }
-    if (craft) domain.add(craft);
     // A business named only by what it sells ("a shop selling pottery") is of that world.
     if (!domain.size) for (const stem of made)domain.add(stem);
+    const groups = CRAFT_KIN.filter((group)=>group.match.some((word)=>domain.has(aiStockStem(word)) || made.has(aiStockStem(word)) || aiStockStem(word) === craft));
+    // A business that is only a place ("an online shop for handmade
+    // cold-process soap") takes its craft from what it is for: the Saltmarsh
+    // Soap Co start (2026-10-10) read its craft as nothing, so its hero searched
+    // "shop" (a florist's bouquet) and no product was held to soap.
+    if (!craft) {
+        var _groups_;
+        const listed = (_groups_ = groups[0]) == null ? void 0 : _groups_.match.map(aiStockStem).find((stem)=>domain.has(stem) || made.has(stem));
+        craft = listed || firstWorld || [
+            ...made
+        ][0] || '';
+        if (craft && !stemList(business).includes(craft)) business = `${craft} ${business}`.trim();
+    }
+    if (craft) domain.add(craft);
     const broad = [];
     const makingSearches = [];
     const rivals = [];
-    for (const group of CRAFT_KIN){
-        if (!group.match.some((word)=>domain.has(aiStockStem(word)) || made.has(aiStockStem(word)))) continue;
+    const core = new Set(craft ? [
+        craft
+    ] : []);
+    const shun = new Set();
+    for (const group of groups){
+        var _group_shun;
+        for (const word of (_group_shun = group.shun) != null ? _group_shun : [])shun.add(aiStockStem(word));
+        for (const word of group.match)core.add(aiStockStem(word));
         for (const word of group.kin)domain.add(aiStockStem(word));
         broad.push(...group.broad);
         makingSearches.push(...group.making);
@@ -892,7 +1140,13 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         named: [
             ...new Set(stemList(businessType))
         ],
-        rivals
+        rivals,
+        core: [
+            ...core
+        ],
+        shun: [
+            ...shun
+        ]
     };
 }
 /** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(list) {
@@ -943,23 +1197,59 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
 /** An object's kin phrases as stems, or none. */ const kinStems = (entry)=>entry ? [
         ...new Set(entry.kin.map((phrase)=>stemList(phrase).join(' ')))
     ] : [];
+/**
+ * A size never names a product (AGL-3660): the Tidewater start searched
+ * "soap set starter size" for "Bath Gift Set Starter Size", its head noun
+ * read as "size", and took a soap dispenser.
+ */ const PRODUCT_SIZES = /\b(?:(?:starter|travel|trial|sample|mini|full|half|family|value|jumbo|large|small|regular|standard|big)[- ])?sized?s?\b/gi;
+/** The wrapper words a gift is named by, searched with the craft: "soap gift box". */ const GIFT_WRAPPERS = words('gift gifts box boxes basket baskets hamper hampers');
 /**
  * A product's searches (AGL-3676), most specific first: each of its subjects
  * — its name's noun phrase, then its photo's — with the shop's category
- * where the phrase does not already say it ("candle gift box"), then the
- * category alone, a plain photo of what the shop sells. Every one must find a
- * hit naming the category, so no product is ever filled with a lifestyle shot
- * of something else: the beta.237 Willow Wick start put a laptop and roses
- * under "Candle Wick Trimmer" and an antique tea set under "Candle Gift Set".
+ * where the phrase does not already name the shop's world ("candle gift
+ * box"), then the category alone, a plain photo of what the shop sells. Every
+ * one must find a hit naming the category — or the product's own word of the
+ * shop's world, "lotion" in a soap shop — so no product is ever filled with a
+ * lifestyle shot of something else: the beta.237 Willow Wick start put a
+ * laptop and roses under "Candle Wick Trimmer" and an antique tea set under
+ * "Candle Gift Set".
  *
- * And every one must find a hit naming the product's own head noun among its
+ * And each must find a hit naming the product's own head noun among its
  * first tags (AGL-3660): the beta.239 Ember & Oak start put a bed with a book,
  * a mug and a camera (its candle a last tag) under "Hand-Poured Soy Candle".
  * An object whose own word is not enough ({@link OBJECT_KIN}) is searched by
  * its kin instead of the category alone, and named by them: a single taper
  * candle filled "Wax Melt Gift Set".
- */ export function aiStockProductSearches(slot, craft, domain = []) {
-    var _ref, _subjects_, _subjects_1;
+ *
+ * Then, before a product is ever given a photo of something else, it falls
+ * back to its own craft (AGL-3660). The Saltmarsh Soap Co start (2026-10-10)
+ * found no hit naming "bar" or "box" among the first tags, and four of its
+ * five products took the starter photos — a laptop and roses, a living room
+ * of plants. And the beta.242 Tidewater Soap Works start (2026-10-11) showed
+ * that the head noun anywhere is not enough: its own weak hits put a sauna
+ * under "Bath Gift Set", colognes under "Natural Body Lotion", a bathroom
+ * shelf under "Soap Bar Trio" and a soap dispenser under its starter size,
+ * while the collection tiles beside them, searched for the category, were
+ * good. So the searches are ranked by how sure they are ({@link AiStockSearch.tier}):
+ *
+ * 1. Its own: the head noun (or its kin) among the first tags, as above.
+ * 2. `borrow`: a photo OF its category — the category alone, then the craft's
+ *    broad searches ("handmade soap", "natural skincare"), one of the
+ *    product's kin or the craft's own names among the first tags. A product
+ *    may repeat one the job already shows, a collection tile's photo or
+ *    another product's ({@link aiLayoutStockPhotoSource}): a borrowed
+ *    on-topic photo beats a weak specific one.
+ * 3. `weak`: the same searches again, the head noun named anywhere among the
+ *    tags (no extra search: the page remembers its answers), a gift's own
+ *    wrapper with the craft ("soap gift box"), and the craft's broad searches,
+ *    any hit naming the craft itself ({@link AiStockSiteTerms.core}).
+ *
+ * Every one of them turns down a room or a scene, a fragrance bottle, and
+ * what the product's kin shuns (a pump for a bar of soap), unless the
+ * product names it. A size never names the product: "Bath Gift Set Starter
+ * Size" is a bath gift set.
+ */ export function aiStockProductSearches(slot, craft, domain = [], fallback = {}) {
+    var _ref, _subjects_, _fallback_core, _ref1, _fallback_broad, _fallback_broad1;
     var _slot_product;
     const orientation = aiStockOrientation(slot.aspect);
     const size = orientation === 'vertical' ? {
@@ -968,62 +1258,165 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         minWidth: 900
     };
     const craftStems = stemList(craft);
-    const subjects = ((_ref = (_slot_product = slot.product) == null ? void 0 : _slot_product.subjects) != null ? _ref : []).map((raw)=>aiStockSubjectWords(raw, '')).filter(Boolean);
+    const world = new Set([
+        ...domain,
+        ...craftStems
+    ]);
+    const subjects = ((_ref = (_slot_product = slot.product) == null ? void 0 : _slot_product.subjects) != null ? _ref : []).map((raw)=>aiStockSubjectWords(raw.replace(PRODUCT_SIZES, ' '), '')).filter(Boolean);
     // The product's head noun is its name's: "candle" of "Hand-Poured Soy Candle".
-    const object = aiStockObjectWord((_subjects_ = subjects[0]) != null ? _subjects_ : '');
+    const own = (_subjects_ = subjects[0]) != null ? _subjects_ : '';
+    const object = aiStockObjectWord(own);
     const kin = object ? objectKin(object, [
         ...craftStems,
         ...domain,
         ...stemList(subjects.join(' '))
     ]) : null;
     const kinPhrases = kinStems(kin);
+    // A product of the shop's world beside its category is held to either:
+    // a soap shop's body lotion names "lotion", never "soap".
+    const ownWorld = stemList(own).filter((stem)=>world.has(stem) && !WRAPPERS.has(stem) && !craftStems.includes(stem));
+    const category = craft && ownWorld.length ? [
+        ...craftStems,
+        ...ownWorld
+    ] : [];
+    const core = [
+        ...new Set([
+            ...craftStems,
+            ...(_fallback_core = fallback.core) != null ? _fallback_core : []
+        ])
+    ];
+    const shun = ((_ref1 = kin == null ? void 0 : kin.shun) != null ? _ref1 : []).map(aiStockStem);
     const queries = [];
     for (const subject of subjects){
+        var _ref2;
         const stems = stemList(subject);
-        const query = kin ? stems.includes(aiStockStem(kin.qualifier)) ? subject : `${kin.qualifier} ${subject}` : craft && !craftStems.every((stem)=>stems.includes(stem)) ? `${craft} ${subject}` : subject;
+        const qualifier = (_ref2 = kin == null ? void 0 : kin.qualifier) != null ? _ref2 : '';
+        const query = kin ? !qualifier || stems.includes(aiStockStem(qualifier)) ? subject : kin.after ? `${subject} ${qualifier}` : `${qualifier} ${subject}` : craft && !stems.some((stem)=>world.has(stem)) ? `${craft} ${subject}` : subject;
         queries.push({
             query,
             subject,
-            object
+            object,
+            lead: true
         });
     }
-    // The category alone stands in only for a thing that is no more than of it.
-    // Its hits are still scored by the product's own words: a soy candle over a taper.
-    const own = (_subjects_1 = subjects[0]) != null ? _subjects_1 : '';
+    // The category alone stands in only for a thing that is no more than of
+    // it; a thing that is its own word of the shop's world is searched by that
+    // word ("lotion"). Its hits are still scored by the product's own words: a
+    // soy candle over a taper.
     if (kin) for (const query of kin.queries)queries.push({
         query,
         subject: own || query,
-        object
+        object,
+        lead: true
+    });
+    else if (object && ownWorld.includes(object)) queries.push({
+        query: object,
+        subject: own,
+        object,
+        lead: true
     });
     else if (craft) queries.push({
         query: craft,
         subject: own || craft,
-        object: craft
+        object: craft,
+        lead: true,
+        tier: 'borrow'
     });
+    const held = [
+        ...queries
+    ];
+    // 2. A photo OF its category, which may be one the job already shows.
+    for (const query of (_fallback_broad = fallback.broad) != null ? _fallback_broad : [])queries.push({
+        query,
+        subject: own,
+        object: '',
+        lead: true,
+        broad: true,
+        tier: 'borrow'
+    });
+    // 3. The head noun anywhere among the tags, by the same searches.
+    for (const entry of held)queries.push(_extends({}, entry, {
+        lead: false,
+        tier: 'weak'
+    }));
+    // A gift is its craft's: "bath gift box" asks for a "soap gift box".
+    const wrapped = own.split(/\s+/).filter((word)=>WRAPPERS.has(word) && aiStockStem(word) !== object);
+    const gift = wrapped.find((word)=>GIFT_WRAPPERS.has(word));
+    if (craft && gift && !kin) queries.push({
+        query: `${craft} ${wrapped.join(' ')}`,
+        subject: own,
+        object: aiStockStem(gift),
+        lead: false,
+        tier: 'weak'
+    });
+    // The craft's own broad searches, any hit naming the craft.
+    for (const query of (_fallback_broad1 = fallback.broad) != null ? _fallback_broad1 : [])queries.push({
+        query,
+        subject: own,
+        object: '',
+        lead: false,
+        broad: true,
+        tier: 'weak'
+    });
+    // What a borrowed photo is OF: the product's kin, its own word of the shop's world, else the craft.
+    const borrowed = kinPhrases.length ? kinPhrases : ownWorld.length ? ownWorld : core;
     const seen = new Set();
     const searches = [];
     for (const entry of queries){
+        var _entry_tier;
         const query = clip(entry.query);
-        if (!query || seen.has(query)) continue;
-        seen.add(query);
-        searches.push(_extends({
+        const key = `${query}|${entry.lead}|${entry.object}|${entry.broad === true}|${(_entry_tier = entry.tier) != null ? _entry_tier : ''}`;
+        if (!query || seen.has(key)) continue;
+        seen.add(key);
+        const common = _extends({
             query,
             orientation
         }, size, {
             subject: entry.subject,
+            product: true
+        }, entry.tier ? {
+            tier: entry.tier
+        } : {}, shun.length ? {
+            shun
+        } : {});
+        if (entry.broad) {
+            const heldTo = [
+                ...new Set([
+                    ...core,
+                    ...ownWorld
+                ])
+            ];
+            searches.push(_extends({}, common, {
+                broad: true
+            }, entry.lead ? _extends({
+                leadAny: borrowed
+            }, kinPhrases.length ? {
+                kin: kinPhrases
+            } : {}, heldTo.length ? {
+                category: heldTo
+            } : {}) : core.length ? {
+                category: core
+            } : {}));
+            continue;
+        }
+        searches.push(_extends({}, common, entry.lead ? {
             lead: true
+        } : {
+            leadWorld: true
         }, entry.object ? {
             object: entry.object
-        } : {}, kinPhrases.length ? {
+        } : {}, kinPhrases.length && entry.object === object ? {
             kin: kinPhrases
         } : {}, craft ? {
             requires: craft
+        } : {}, category.length ? {
+            category
         } : {}));
     }
     return searches;
 }
 /** The searches a slot tries, in order, most specific first, each distinct. */ export function aiStockSearchesFor(slot, terms, subject, part) {
-    var _terms_making;
+    var _terms_core, _terms_making;
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
         minWidth: 1600
@@ -1042,6 +1435,12 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     const kinPhrases = kinStems(kin);
     // The craft qualifies a subject that does not already name the site's world.
     const namesWorld = subjectStems.some((stem)=>domain.has(stem));
+    // A tile of the shop's world beside its category is held to either: a soap
+    // shop's "Body care" tile names "body", never "soap" (AGL-3660).
+    const ownWorld = subjectStems.filter((stem)=>domain.has(stem) && !WRAPPERS.has(stem) && stem !== terms.craft);
+    // A hero of a craft names the craft itself: the Saltmarsh Soap Co hero
+    // (2026-10-10) was a florist's bouquet tagged "natural" (AGL-3660).
+    const core = (_terms_core = terms.core) != null ? _terms_core : [];
     const qualify = (phrase)=>terms.craft && !namesWorld && !stemList(phrase).includes(terms.craft) ? `${terms.craft} ${phrase}` : phrase;
     // A collection tile is product-like: held to the shop's category and its
     // own object among the first tags, and searched by its object's kin, never
@@ -1117,8 +1516,15 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             kin: kinPhrases
         } : {}, held && collection ? {
             lead: true
-        } : {}, terms.craft && (raw.category || raw.held && collection) ? {
+        } : {}, terms.craft && (raw.category || raw.held && collection) ? _extends({
             requires: terms.craft
+        }, ownWorld.length ? {
+            category: [
+                terms.craft,
+                ...ownWorld
+            ]
+        } : {}) : {}, slot.role === 'hero' && core.length ? {
+            category: core
         } : {}));
     }
     return searches;
@@ -1133,7 +1539,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     }
 }
 /** A hit's words: the first few (what it is OF), every one, and each tag's phrase. */ function hitWords(photo) {
-    var _photo_tags, _photo_alt, _photo_alt1, _photo_alt2;
+    var _photo_tags, _photo_alt, _photo_alt1, _tags_, _photo_alt2;
     const slug = pageSlug(photo.pageUrl);
     const tags = ((_photo_tags = photo.tags) != null ? _photo_tags : []).map((tag)=>tag.toLowerCase().trim()).filter(Boolean);
     const lead = new Set(stemList([
@@ -1154,6 +1560,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         ...tags.slice(0, 3).map((tag)=>stemList(tag).join(' ')),
         stemList(slug).join(' ')
     ];
+    /** The first tag: what the photo is most of all. */ const firstPhrase = stemList((_tags_ = tags[0]) != null ? _tags_ : '').join(' ');
     const rejected = tags.some((tag)=>REJECTED_TAGS.has(tag) || tag.split(/\s+/).some((word)=>REJECTED_TAGS.has(word)));
     // Whole words only, a hyphenated one kept whole: "cross-stitch" is not a cross.
     const words = new Set([
@@ -1165,6 +1572,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         all,
         phrases,
         leadPhrases,
+        firstPhrase,
         rejected,
         words
     };
@@ -1193,25 +1601,59 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * the subject's two-word phrase 3, each of its other words 1, and the
  * site's world 1, plus a quarter when it is among the first tags.
  */ export function aiStockRelevance(photo, judgement) {
-    var _judgement_rivals, _judgement_kin, _judgement_requires, _judgement_subject, _judgement_object, _judgement_domain;
+    var _judgement_rivals, _judgement_subject, _judgement_named, _judgement_shun, _judgement_leadAny, _judgement_kin, _judgement_requires, _judgement_category, _judgement_object, _judgement_domain;
     const hit = hitWords(photo);
     if (hit.rejected) return 0;
     if (aiStockSensitive(photo, judgement.named)) return 0;
     // Glass art is not pottery: a rival craft's photo names this craft's own words.
     for (const rival of (_judgement_rivals = judgement.rivals) != null ? _judgement_rivals : [])if (rival.words.some((word)=>hit.all.has(word)) && !rival.core.some((word)=>hit.all.has(word))) return 0;
+    const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
+    // What the slot or the brief names lets a shunned word, a room or a fragrance in.
+    const owned = new Set([
+        ...subject,
+        ...(_judgement_named = judgement.named) != null ? _judgement_named : []
+    ]);
+    // A dispenser is not a soapmaker's, nor a pump a bar's (AGL-3660).
+    if (((_judgement_shun = judgement.shun) != null ? _judgement_shun : []).some((word)=>hit.all.has(word) && !owned.has(word))) return 0;
+    if (judgement.product) {
+        // A sauna, a bathroom shelf: a room is never the product.
+        for (const word of hit.lead)if (PRODUCT_SCENES.has(word) && !owned.has(word)) return 0;
+        // Colognes are not a lotion: a fragrance's bottle only for a fragrance.
+        if (![
+            ...FRAGRANCE_BOTTLES
+        ].some((word)=>owned.has(word)) && [
+            ...hit.lead
+        ].some((word)=>FRAGRANCE_BOTTLES.has(word))) return 0;
+    }
+    // A borrowed photo is OF the product's category.
+    const leadAny = (_judgement_leadAny = judgement.leadAny) != null ? _judgement_leadAny : [];
+    if (leadAny.length && !leadAny.some((phrase)=>among(hit.leadPhrases, phrase))) return 0;
     const kin = (_judgement_kin = judgement.kin) != null ? _judgement_kin : [];
     const kinNamed = kin.some((phrase)=>among(hit.phrases, phrase));
     const kinLead = kin.some((phrase)=>among(hit.leadPhrases, phrase));
     const required = stemList((_judgement_requires = judgement.requires) != null ? _judgement_requires : '');
+    const category = ((_judgement_category = judgement.category) != null ? _judgement_category : []).flatMap(stemList);
+    const anyOf = category.length ? [
+        ...new Set([
+            ...required,
+            ...category
+        ])
+    ] : [];
+    const demanded = required.length > 0 || anyOf.length > 0;
+    const meets = anyOf.length ? anyOf.some((stem)=>hit.all.has(stem)) : required.every((stem)=>hit.all.has(stem));
     // An object's kin stands for the category: a wax melt is the candle shop's.
-    if (!kinNamed && required.some((stem)=>!hit.all.has(stem))) return 0;
-    const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
+    if (demanded && !kinNamed && !meets) return 0;
     const object = (_judgement_object = judgement.object) != null ? _judgement_object : judgement.subject ? aiStockObjectWord(judgement.subject) : '';
     const domain = ((_judgement_domain = judgement.domain) != null ? _judgement_domain : []).filter((stem)=>stem !== object);
     // A hit naming the word it must name is of the site's world: a product's
     // category is that world even where it is the product's own object.
-    const world = required.length > 0 || kinNamed || domain.some((stem)=>hit.all.has(stem));
-    const worldLead = required.length > 0 && required.every((stem)=>hit.lead.has(stem)) || kinLead || domain.some((stem)=>hit.lead.has(stem));
+    const world = demanded || kinNamed || domain.some((stem)=>hit.all.has(stem));
+    const worldLead = (anyOf.length ? anyOf.some((stem)=>hit.lead.has(stem)) : required.length > 0 && required.every((stem)=>hit.lead.has(stem))) || kinLead || domain.some((stem)=>hit.lead.has(stem));
+    if (judgement.leadWorld && !worldLead) return 0;
+    // What the photo is most of all: its first tag names the object, its kin or what it must be OF.
+    const firstNamed = (phrases)=>phrases.some((phrase)=>Boolean(phrase) && among([
+                hit.firstPhrase
+            ], phrase));
     const pair = subject.length >= 2 ? subject.slice(-2).join(' ') : '';
     const phrased = Boolean(pair) && among(hit.phrases, pair);
     let score = 0;
@@ -1225,9 +1667,13 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         if (domain.length && !world && !phrased) return 0;
         score += leading ? 4 : 2;
         if (kinNamed) score += 3;
+        if (firstNamed(kin.length ? kin : [
+            object
+        ])) score += 1;
     } else if (domain.length) {
         if (!world) return 0;
     }
+    if (leadAny.length && firstNamed(leadAny)) score += 1;
     if (phrased) score += 3;
     for (const word of new Set(subject))if (word !== object && hit.all.has(word)) score += 1;
     if (world) score += worldLead ? 1.25 : 1;
@@ -1345,6 +1791,8 @@ const EXTENSIONS = {
             delete request.object;
             delete request.kin;
             delete request.lead;
+            delete request.leadWorld;
+            delete request.category;
             const key = JSON.stringify([
                 request.query,
                 request.orientation,
@@ -1363,7 +1811,7 @@ const EXTENSIONS = {
             answers.set(key, asked);
             return asked;
         };
-        /** The photo placed in the site's library, a copy it holds or a new one; `null` when it cannot be placed. */ const keep = async (photo, slot, query)=>{
+        /** The photo placed in the site's library, a copy it holds or a new one; `null` when it cannot be placed. */ const keep = async (photo, slot, query, repeat = false)=>{
             const sourceKey = stockPhotoSourceKey(photo);
             try {
                 var _EXTENSIONS_bytes_contentType;
@@ -1374,7 +1822,7 @@ const EXTENSIONS = {
                 if (kept) {
                     var _kept_width, _kept_height;
                     // Held because a slot of this page or another page of the job shows it.
-                    if (placedSrcs.has(kept.src) || elsewhere(kept.src)) return null;
+                    if (!repeat && (placedSrcs.has(kept.src) || elsewhere(kept.src))) return null;
                     remember(sourceKey, kept.src);
                     return {
                         src: kept.src,
@@ -1437,6 +1885,65 @@ const EXTENSIONS = {
             }
             return null;
         };
+        /** How a search's hits are judged for a slot. */ const judgementFor = (slot, request, subject)=>{
+            var _request_subject, _request_shun;
+            var _request_shun1, _request_leadAny;
+            return _extends({
+                subject: (_request_subject = request.subject) != null ? _request_subject : request.broad ? '' : subject,
+                domain: terms.domain,
+                strict: slot.role === 'gallery' && !request.broad || !!request.requires,
+                named: terms.named,
+                rivals: terms.rivals
+            }, terms.shun.length || ((_request_shun1 = request.shun) == null ? void 0 : _request_shun1.length) ? {
+                shun: [
+                    ...new Set([
+                        ...terms.shun,
+                        ...(_request_shun = request.shun) != null ? _request_shun : []
+                    ])
+                ]
+            } : {}, request.product ? {
+                product: true
+            } : {}, ((_request_leadAny = request.leadAny) == null ? void 0 : _request_leadAny.length) ? {
+                leadAny: request.leadAny
+            } : {}, request.requires ? {
+                requires: request.requires
+            } : {}, request.category ? {
+                category: request.category
+            } : {}, request.object ? {
+                object: request.object
+            } : {}, request.kin ? {
+                kin: request.kin
+            } : {}, request.lead ? {
+                lead: true
+            } : {}, request.leadWorld ? {
+                leadWorld: true
+            } : {});
+        };
+        /**
+     * The craft's own photos, the last thing a slot of a craft's site is
+     * filled from (AGL-3660): its broad searches, any hit naming the craft
+     * itself. Never a desk, a laptop or a living room for a soap shop.
+     */ const craftSearches = (slot)=>{
+            if (!terms.core.length) return [];
+            const orientation = aiStockOrientation(slot.aspect);
+            const size = slot.role === 'hero' ? {
+                minWidth: 1600
+            } : orientation === 'vertical' ? {
+                minHeight: 900
+            } : {
+                minWidth: 900
+            };
+            return terms.broad.map((query)=>_extends({
+                    query: clip(query),
+                    orientation
+                }, size, {
+                    broad: true,
+                    category: terms.core
+                }, slot.product ? {
+                    product: true,
+                    tier: 'weak'
+                } : {}));
+        };
         // 1. Choose, slot by slot, so the page's choices never collide: each
         //    slot claims its best accepted hit before the next slot looks.
         const choices = [];
@@ -1449,45 +1956,85 @@ const EXTENSIONS = {
             const sectionName = (_input_sectionNames_slot_sectionIndex = input.sectionNames[slot.sectionIndex]) != null ? _input_sectionNames_slot_sectionIndex : '';
             const subject = aiStockSubjectWords(slot.alt, sectionName);
             let choice = null;
-            const requests = slot.product ? aiStockProductSearches(slot, terms.craft, terms.domain) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName));
-            for (const request of requests){
-                var _request_subject;
-                if (choice || signal.aborted) break;
+            const requests = [
+                ...slot.product ? aiStockProductSearches(slot, terms.craft, terms.domain, {
+                    broad: terms.broad,
+                    core: terms.core
+                }) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName)),
+                ...craftSearches(slot)
+            ];
+            /** The slot's accepted hits for a search; `null` once the page's searches are spent. */ const accepted = async (request, repeat)=>{
                 const found = await search(request);
-                if (found === null) break;
-                const blocked = new Set(claimed);
-                for (const hit of found){
-                    const key = stockPhotoSourceKey(hit);
-                    if (elsewhere(key)) blocked.add(key);
+                if (found === null) return null;
+                const blocked = new Set();
+                if (!repeat) {
+                    for (const key of claimed)blocked.add(key);
+                    for (const hit of found){
+                        const key = stockPhotoSourceKey(hit);
+                        if (elsewhere(key)) blocked.add(key);
+                    }
                 }
-                const ranked = aiStockRank(found, blocked, `${input.seed}:${index}:${request.query}`, _extends({
-                    subject: (_request_subject = request.subject) != null ? _request_subject : request.broad ? '' : subject,
-                    domain: terms.domain,
-                    strict: slot.role === 'gallery' && !request.broad || !!request.requires,
-                    named: terms.named,
-                    rivals: terms.rivals
-                }, request.requires ? {
-                    requires: request.requires
-                } : {}, request.object ? {
-                    object: request.object
-                } : {}, request.kin ? {
-                    kin: request.kin
-                } : {}, request.lead ? {
-                    lead: true
-                } : {}));
-                if (!ranked.length) continue;
-                const first = ranked[0];
-                claimed.add(stockPhotoSourceKey(first));
-                choice = {
-                    candidates: ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SLOT),
-                    query: request.query
-                };
+                return aiStockRank(found, blocked, `${input.seed}:${index}:${request.query}`, judgementFor(slot, request, subject));
+            };
+            /** The first of these searches with a hit to take: a new one, or one the job already shows. */ const choose = async (tried, repeat)=>{
+                for (const request of tried){
+                    if (signal.aborted) return null;
+                    // Spent searches answer nothing; those already asked still answer from memory.
+                    const ranked = await accepted(request, repeat);
+                    if (!(ranked == null ? void 0 : ranked.length)) continue;
+                    if (!repeat) claimed.add(stockPhotoSourceKey(ranked[0]));
+                    return _extends({
+                        candidates: ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SLOT),
+                        query: request.query
+                    }, repeat ? {
+                        repeat: true
+                    } : {});
+                }
+                return null;
+            };
+            // 2. Nothing new of its own: a product or a hero reuses an on-topic
+            //    photo another slot of the job already shows (a product may repeat
+            //    a collection tile's photo, or another product's) before the
+            //    starters' desk or living room fills it (AGL-3660). Any other
+            //    picture keeps "never twice". A product goes by how sure each
+            //    search is: its own and its category's photos, new and then
+            //    repeated, before a weak hit of its own (the Tidewater sauna).
+            const repeats = Boolean(slot.product) || slot.role === 'hero';
+            const sure = slot.product ? requests.filter((request)=>request.tier !== 'weak') : requests;
+            const unsure = slot.product ? requests.filter((request)=>request.tier === 'weak') : [];
+            const phases = [
+                [
+                    sure,
+                    false
+                ],
+                ...repeats ? [
+                    [
+                        sure,
+                        true
+                    ]
+                ] : [],
+                ...unsure.length ? [
+                    [
+                        unsure,
+                        false
+                    ],
+                    [
+                        unsure,
+                        true
+                    ]
+                ] : []
+            ];
+            for (const [tried, repeat] of phases){
+                if (choice || signal.aborted) break;
+                choice = await choose(tried, repeat);
             }
             choices.push(choice);
         }
-        // 2. Keep, a few at a time; a copy that fails tries the slot's next
-        //    accepted hit no other slot has claimed.
+        // 3. Keep, a few at a time; a copy that fails tries the slot's next
+        //    accepted hit no other slot has claimed. A repeat waits for the
+        //    slot it repeats, so the library never holds a photo twice.
         const photos = slots.map(()=>null);
+        /** What this pass placed, by source key. */ const placedByKey = new Map();
         const fill = async (index)=>{
             const choice = choices[index];
             const slot = slots[index];
@@ -1495,28 +2042,43 @@ const EXTENSIONS = {
             for (const [rank, candidate] of choice.candidates.entries()){
                 if (signal.aborted) return;
                 const key = stockPhotoSourceKey(candidate);
+                if (choice.repeat) {
+                    var _placedByKey_get;
+                    const placed = (_placedByKey_get = placedByKey.get(key)) != null ? _placedByKey_get : await keep(candidate, slot, choice.query, true);
+                    if (placed) {
+                        photos[index] = placed;
+                        return;
+                    }
+                    continue;
+                }
                 if (rank > 0) {
                     if (claimed.has(key)) continue;
                     claimed.add(key);
                 }
                 const placed = await keep(candidate, slot, choice.query);
                 if (placed) {
+                    placedByKey.set(key, placed);
                     photos[index] = placed;
                     return;
                 }
             }
         };
+        const firsts = slots.map((_slot, index)=>index).filter((index)=>{
+            var _choices_index;
+            return !((_choices_index = choices[index]) == null ? void 0 : _choices_index.repeat);
+        });
         let next = 0;
         const worker = async ()=>{
-            while(next < slots.length){
-                const index = next;
+            while(next < firsts.length){
+                const index = firsts[next];
                 next += 1;
                 await fill(index);
             }
         };
         await Promise.all(Array.from({
-            length: Math.min(AI_LAYOUT_STOCK_COPIES_AT_ONCE, slots.length)
+            length: Math.min(AI_LAYOUT_STOCK_COPIES_AT_ONCE, firsts.length)
         }, worker));
+        for (const [index, choice] of choices.entries())if (choice == null ? void 0 : choice.repeat) await fill(index);
         return photos;
     };
 }