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

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

@@ -95,6 +95,18 @@ 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.
+ *
  * 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 +132,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');
@@ -469,6 +482,35 @@ 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'
+        ]
     }
 ];
 /** An object's kin where the site or the subject is of its world, else `null`. */ function objectKin(object, world) {
@@ -595,22 +637,53 @@ 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'
+            ]
+        }
     },
     {
         match: [
@@ -837,10 +910,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 +932,34 @@ 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
+    ] : []);
+    for (const group of groups){
+        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 +984,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         named: [
             ...new Set(stemList(businessType))
         ],
-        rivals
+        rivals,
+        core: [
+            ...core
+        ]
     };
 }
 /** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(list) {
@@ -943,23 +1038,41 @@ 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(' ')))
     ] : [];
+/** 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. So, in order:
+ *
+ * 1. The same searches again, the head noun named anywhere among the tags
+ *    (no extra search: the page remembers its answers), and a gift's own
+ *    wrapper with the craft ("soap gift box").
+ * 2. The site's broad searches ("handmade soap", "natural skincare"), any hit
+ *    naming the craft itself ({@link AiStockSiteTerms.core}).
+ *
+ * The source then reuses an on-topic photo another slot of the job already
+ * shows before it gives up ({@link aiLayoutStockPhotoSource}).
+ */ export function aiStockProductSearches(slot, craft, domain = [], fallback = {}) {
+    var _ref, _subjects_, _fallback_broad, _fallback_core;
     var _slot_product;
     const orientation = aiStockOrientation(slot.aspect);
     const size = orientation === 'vertical' ? {
@@ -968,62 +1081,131 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         minWidth: 900
     };
     const craftStems = stemList(craft);
+    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, '')).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 queries = [];
     for (const subject of subjects){
         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 query = kin ? stems.includes(aiStockStem(kin.qualifier)) ? subject : `${kin.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
+    });
+    // 1. The head noun anywhere among the tags, by the same searches.
+    for (const entry of [
+        ...queries
+    ])queries.push(_extends({}, entry, {
+        lead: false
+    }));
+    // 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
     });
+    // 2. The craft's own broad searches, any hit naming the craft.
+    for (const query of (_fallback_broad = fallback.broad) != null ? _fallback_broad : [])queries.push({
+        query,
+        subject: own,
+        object: '',
+        lead: false,
+        broad: true
+    });
+    const core = [
+        ...new Set([
+            ...craftStems,
+            ...(_fallback_core = fallback.core) != null ? _fallback_core : []
+        ])
+    ];
     const seen = new Set();
     const searches = [];
     for (const entry of queries){
         const query = clip(entry.query);
-        if (!query || seen.has(query)) continue;
-        seen.add(query);
+        const key = `${query}|${entry.lead}|${entry.object}|${entry.broad === true}`;
+        if (!query || seen.has(key)) continue;
+        seen.add(key);
+        if (entry.broad) {
+            searches.push(_extends({
+                query,
+                orientation
+            }, size, {
+                broad: true,
+                subject: entry.subject
+            }, core.length ? {
+                category: core
+            } : {}));
+            continue;
+        }
         searches.push(_extends({
             query,
             orientation
         }, size, {
-            subject: entry.subject,
+            subject: entry.subject
+        }, 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 +1224,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 +1305,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;
@@ -1193,7 +1388,7 @@ 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_kin, _judgement_requires, _judgement_category, _judgement_subject, _judgement_object, _judgement_domain;
     const hit = hitWords(photo);
     if (hit.rejected) return 0;
     if (aiStockSensitive(photo, judgement.named)) return 0;
@@ -1203,15 +1398,25 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     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;
+    if (demanded && !kinNamed && !meets) return 0;
     const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
     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;
     const pair = subject.length >= 2 ? subject.slice(-2).join(' ') : '';
     const phrased = Boolean(pair) && among(hit.phrases, pair);
     let score = 0;
@@ -1345,6 +1550,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 +1570,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 +1581,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 +1644,50 @@ const EXTENSIONS = {
             }
             return null;
         };
+        /** How a search's hits are judged for a slot. */ const judgementFor = (slot, request, subject)=>{
+            var _request_subject;
+            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
+            }, 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
+                }));
+        };
         // 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,32 +1700,30 @@ 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
-                } : {}));
+                return aiStockRank(found, blocked, `${input.seed}:${index}:${request.query}`, judgementFor(slot, request, subject));
+            };
+            for (const request of requests){
+                if (choice || signal.aborted) break;
+                const ranked = await accepted(request, false);
+                if (ranked === null) break;
                 if (!ranked.length) continue;
                 const first = ranked[0];
                 claimed.add(stockPhotoSourceKey(first));
@@ -1483,11 +1732,30 @@ const EXTENSIONS = {
                     query: request.query
                 };
             }
+            // 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) before the starters' desk or living
+            //    room fills it (AGL-3660). Only the searches already answered are
+            //    asked again, from memory. Any other picture keeps "never twice".
+            if (!choice && (slot.product || slot.role === 'hero')) {
+                for (const request of requests){
+                    if (choice || signal.aborted) break;
+                    const ranked = await accepted(request, true);
+                    if (!(ranked == null ? void 0 : ranked.length)) continue;
+                    choice = {
+                        candidates: ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SLOT),
+                        query: request.query,
+                        repeat: true
+                    };
+                }
+            }
             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 +1763,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;
     };
 }