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

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

@@ -17,6 +17,7 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
  */ import { pluginMediaIngest } from "@aglyn/aglyn/plugin-manager/plugin-media-ingest";
 import { STOCK_PHOTO_QUERY_MAX_CHARS, stockPhotoProvider, stockPhotoSourceKey } from "@aglyn/aglyn/plugin-manager/stock-photo-provider";
 import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
+import { aiStorefrontSays } from "../layout-language/ai-layout-storefront.js";
 /**
  * STOCK PHOTOS FOR A LANGUAGE PAGE'S PICTURE SLOTS (AGL-3660).
  *
@@ -70,6 +71,17 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
  *    ranked: the object in the hit's first tags (what the photo is OF) over
  *    a mention in its last, the subject's other words, the domain. Among
  *    equals the job's seed picks, so two sites differ and one job repeats.
+ *    What the beta.239 Ember & Oak start added: "hand-poured", "handmade"
+ *    and "by hand" never make "hands" a subject, and a story of the craft
+ *    asks for the maker at work ("candle making"); a hit carrying a topic
+ *    the brief never named (a cross, a grave, a flag, a gun, wine, a child,
+ *    a mannequin) never fills anything; a product, and a collection tile,
+ *    take only a hit naming its head noun among the first tags, held to the
+ *    shop's category; and an object whose word is not enough ("melt") is
+ *    named and searched by its kin ("wax melt", "melt warmer"), never by the
+ *    category alone. And from the Kiln & Clover portfolio: nudity never fills
+ *    anything, for any business; a hit naming a rival craft (glass, for a
+ *    potter) counts only when it names the craft's own words too.
  * 4. **Never twice.** A photo is placed once per job: not twice on a page,
  *    and not on a page when another page (or another pass, in this process)
  *    of the same job already placed it. The caller hands in what the job's
@@ -83,6 +95,18 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.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
@@ -98,12 +122,18 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
  * The unit job input naming the screen drafts the job's other pages were
  * written to, whose photos a page does not place again (AGL-3660).
  */ export const AI_STOCK_PHOTO_PAGES_INPUT = 'stockPhotoPages';
+/**
+ * The unit job input naming library photos (`media:` references) another
+ * part of the job already shows outside its pages — a dataset's records
+ * (AGL-3616) — which a page does not place again.
+ */ export const AI_STOCK_PHOTO_AVOID_INPUT = 'stockPhotoAvoid';
 const words = (list)=>new Set(list.trim().split(/\s+/));
 /** Words that carry no subject. */ const STOPWORDS = words('a an the and or of in on at to for with from by into onto over under near our your their my his her its ' + 'this that these those is are be being was were who whom which where while as about than then very just ' + 'small local best new top quality premium family-owned family owned independent professional ' + 'business company services service page photo picture image showing shows show ' + 'someone people person one two three some many several');
 /**
  * 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 ' + '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');
@@ -119,6 +149,374 @@ 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');
+/**
+ * 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
+ * showed devotional candles with crosses and names). A hit tagged with any
+ * word of a topic is rejected unless the site's business type or brief says
+ * one of the topic's words or its `allow` words. The last topic is not
+ * sensitive but is never the thing: the same start's story band showed bronze
+ * mannequin hands tagged "wax".
+ */ const SENSITIVE_TOPICS = [
+    {
+        // Religion.
+        words: [
+            'cross',
+            'crosses',
+            'crucifix',
+            'church',
+            'chapel',
+            'cathedral',
+            'jesus',
+            'christ',
+            'christian',
+            'christianity',
+            'god',
+            'bible',
+            'rosary',
+            'prayer',
+            'pray',
+            'praying',
+            'worship',
+            'worships',
+            'religion',
+            'religious',
+            'faith',
+            'islam',
+            'islamic',
+            'muslim',
+            'mosque',
+            'quran',
+            'temple',
+            'buddha',
+            'buddhism',
+            'buddhist',
+            'hindu',
+            'hinduism',
+            'synagogue',
+            'jewish',
+            'judaism',
+            'ecclesiastical',
+            'saint',
+            'altar',
+            'sacrificial',
+            'nativity',
+            'priest',
+            'nun',
+            'monk'
+        ],
+        allow: [
+            'ministry',
+            'parish',
+            'congregation',
+            'wedding'
+        ]
+    },
+    {
+        // Death and mourning.
+        words: [
+            'funeral',
+            'memorial',
+            'grave',
+            'gravestone',
+            'cemetery',
+            'tomb',
+            'death',
+            'dead',
+            'grief',
+            'mourning',
+            'condolence',
+            'coffin',
+            'skull'
+        ],
+        allow: [
+            'hospice',
+            'mortuary',
+            'cremation',
+            'obituary',
+            'halloween'
+        ]
+    },
+    {
+        // Politics.
+        words: [
+            'political',
+            'politics',
+            'protest',
+            'protester',
+            'demonstration',
+            'rally',
+            'flag',
+            'election',
+            'vote',
+            'voting',
+            'parliament',
+            'government'
+        ],
+        allow: [
+            'advocacy',
+            'campaign',
+            'candidate',
+            'council',
+            'nonprofit'
+        ]
+    },
+    {
+        // Weapons and war.
+        words: [
+            'gun',
+            'rifle',
+            'pistol',
+            'weapon',
+            'firearm',
+            'ammunition',
+            'bullet',
+            'sword',
+            'war',
+            'military',
+            'army',
+            'soldier'
+        ],
+        allow: [
+            'hunting',
+            'archery',
+            'martial',
+            'fencing',
+            'veteran'
+        ]
+    },
+    {
+        // Alcohol, for a business that does not serve it.
+        words: [
+            'alcohol',
+            'wine',
+            'beer',
+            'whiskey',
+            'whisky',
+            'vodka',
+            'cocktail',
+            'liquor',
+            'rum',
+            'gin',
+            'champagne',
+            'drunk'
+        ],
+        allow: [
+            'winery',
+            'vineyard',
+            'brewery',
+            'distillery',
+            'pub',
+            'tavern',
+            'taproom',
+            'bartender',
+            'sommelier',
+            'spirits'
+        ]
+    },
+    {
+        // Tobacco and drugs.
+        words: [
+            'cigarette',
+            'smoking',
+            'tobacco',
+            'cannabis',
+            'marijuana',
+            'drug',
+            'drugs'
+        ],
+        allow: [
+            'dispensary',
+            'vape',
+            'cigar'
+        ]
+    },
+    {
+        // Children, for a business that is not about them.
+        words: [
+            'child',
+            'children',
+            'kid',
+            'kids',
+            'baby',
+            'babies',
+            'toddler',
+            'infant'
+        ],
+        allow: [
+            'nursery',
+            'daycare',
+            'preschool',
+            'kindergarten',
+            'school',
+            'tutor',
+            'tutoring',
+            'parent',
+            'parents',
+            'parenting',
+            'family',
+            'families',
+            'pediatric',
+            'paediatric',
+            'newborn',
+            'maternity'
+        ]
+    },
+    {
+        // Nudity, for every business: no word of a brief lets it in (Kiln &
+        // Clover, 2026-10-10: a nude torso sculpture filled "About the artist").
+        // Never bare "body": a skincare shop's body lotion is its product.
+        words: [
+            'nude',
+            'nudes',
+            'nudity',
+            'naked',
+            'torso',
+            'breast',
+            'breasts',
+            'erotic',
+            'sensual',
+            'lingerie',
+            'bikini'
+        ],
+        allow: [],
+        always: true
+    },
+    {
+        // Figures, never the maker: mannequin hands are not a candlemaker's.
+        words: [
+            'mannequin',
+            'mannequins',
+            'dummy',
+            'statue',
+            'sculpture',
+            'figurine',
+            'doll',
+            'dolls',
+            'waxwork'
+        ],
+        allow: [
+            'sculptor',
+            'museum',
+            'fashion',
+            'boutique',
+            'clothing',
+            'apparel',
+            'toy',
+            'toys'
+        ]
+    }
+];
+/** Each topic's words and the words that allow it, as stems. */ const SENSITIVE_STEMS = SENSITIVE_TOPICS.map((topic)=>{
+    var _topic_allow;
+    return {
+        words: new Set(topic.words.map(aiStockStem)),
+        allow: new Set(topic.always ? [] : [
+            ...topic.words,
+            ...(_topic_allow = topic.allow) != null ? _topic_allow : []
+        ].map(aiStockStem))
+    };
+});
+/**
+ * Hands are never a picture's subject (AGL-3660): "hand-poured", "handmade"
+ * and "by hand" say how a thing was made, and a search for "hands" found
+ * bronze mannequin hands for the beta.239 Ember & Oak story band. Each of
+ * these is dropped from a picture's words; a hand only stays where it names
+ * a thing sold for hands ("hand cream").
+ */ const HAND_IDIOMS = [
+    /\b(?:made\s+|poured\s+|crafted\s+|finished\s+|done\s+)?by\s+(?:our\s+|my\s+|their\s+)?(?:own\s+)?hands?\b/g,
+    /\bwith\s+(?:our|my|their)\s+(?:own\s+)?(?:two\s+)?hands\b/g,
+    /\bhand[- ]?(?:poured|made|crafted|thrown|built|painted|dyed|stitched|sewn|knit|knitted|carved|tied|lettered|blown|bound|rolled|dipped|picked|forged|woven|cut|finished|mixed|cast|formed|shaped|pressed|printed|wrapped|selected|blended|turned|glazed)\b/g,
+    /\bhands?\b(?!\s+(?:creams?|soaps?|lotions?|wash|towels?|saniti[sz]ers?|salves?|balms?|tools?|saws?|planes?|drills?|mixers?|puppets?|bags?|warmers?))/g
+];
+/** A text without its hands. */ function withoutHands(text) {
+    return HAND_IDIOMS.reduce((out, idiom)=>out.replace(idiom, ' '), text.toLowerCase());
+}
+/** Whether a text says how a thing was made by hand: a maker at work. */ function saysMadeByHand(text) {
+    const lower = text.toLowerCase();
+    return HAND_IDIOMS.some((idiom)=>{
+        idiom.lastIndex = 0;
+        const found = idiom.test(lower);
+        idiom.lastIndex = 0;
+        return found;
+    });
+}
+/**
+ * The kin of a few objects whose own word is not enough (AGL-3660): a "melt"
+ * is any melting thing (the beta.239 "Wax melts" tile showed resin fluid
+ * art), so a wax melt names one of these phrases. `within` is the world they
+ * are of; `qualifier` the word a search adds; `queries` the searches for the
+ * object itself, which stand in for the shop's category alone: a candle is
+ * not a wax melt.
+ */ const OBJECT_KIN = [
+    {
+        objects: [
+            'melt',
+            'tart',
+            'cube'
+        ],
+        within: [
+            'wax',
+            'candle',
+            'soy'
+        ],
+        qualifier: 'wax',
+        kin: [
+            'wax melt',
+            'wax melts',
+            'wax cube',
+            'wax cubes',
+            'wax tart',
+            'wax tarts',
+            'melt warmer',
+            'wax warmer',
+            'tart warmer',
+            'oil burner',
+            'oil warmer',
+            'aroma burner',
+            'scent warmer',
+            'fragrance warmer'
+        ],
+        queries: [
+            'wax melts',
+            '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) {
+    var _OBJECT_KIN_find;
+    return (_OBJECT_KIN_find = OBJECT_KIN.find((entry)=>entry.objects.some((word)=>aiStockStem(word) === object) && entry.within.some((word)=>world.includes(aiStockStem(word))))) != null ? _OBJECT_KIN_find : null;
+}
 /**
  * The kin of a few common crafts: the words a photo of that world is
  * tagged with, and the broad searches that find it. A craft not listed
@@ -150,6 +548,33 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'handmade ceramics',
             'pottery'
+        ],
+        rivals: {
+            words: [
+                'glass',
+                'glassware',
+                'glasswork',
+                'glassblowing',
+                'blown',
+                'stained',
+                'murano',
+                'crystal'
+            ],
+            core: [
+                'ceramic',
+                'ceramics',
+                'pottery',
+                'potter',
+                'stoneware',
+                'porcelain',
+                'earthenware',
+                'clay',
+                'terracotta'
+            ]
+        },
+        making: [
+            'pottery wheel',
+            'potter at work'
         ]
     },
     {
@@ -171,6 +596,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'handmade candles',
             'scented candles'
+        ],
+        making: [
+            'candle making',
+            'pouring wax'
         ]
     },
     {
@@ -196,6 +625,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'handmade jewelry',
             'jewelry'
+        ],
+        making: [
+            'jewelry making',
+            'jeweler at work'
         ]
     },
     {
@@ -204,19 +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',
+            '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: [
@@ -242,6 +709,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'woodworking',
             'wooden furniture'
+        ],
+        making: [
+            'woodworking workshop',
+            'carpenter at work'
         ]
     },
     {
@@ -266,6 +737,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'bakery',
             'fresh bread'
+        ],
+        making: [
+            'baker kneading dough',
+            'baking bread'
         ]
     },
     {
@@ -288,6 +763,9 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'coffee shop',
             'coffee'
+        ],
+        making: [
+            'barista making coffee'
         ]
     },
     {
@@ -307,6 +785,9 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'florist',
             'flower bouquet'
+        ],
+        making: [
+            'florist arranging flowers'
         ]
     },
     {
@@ -336,6 +817,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'handmade textiles',
             'yarn'
+        ],
+        making: [
+            'knitting',
+            'weaving loom'
         ]
     },
     {
@@ -354,6 +839,9 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         broad: [
             'leather craft',
             'leather goods'
+        ],
+        making: [
+            'leather crafting'
         ]
     }
 ];
@@ -422,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)){
@@ -440,18 +929,44 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         // What it makes names its world by what the things are made of, never
         // the things: "stoneware" of "stoneware bowls", "soy" of "soy candles".
         // A bowl is not a ceramic world; a robin's food bowl is not pottery.
-        const world = making ? kept.slice(0, -1) : kept;
+        // 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 = [];
-    for (const group of CRAFT_KIN){
-        if (!group.match.some((word)=>domain.has(aiStockStem(word)) || made.has(aiStockStem(word)))) continue;
+    const makingSearches = [];
+    const rivals = [];
+    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);
+        if (group.rivals) rivals.push({
+            words: group.rivals.words.map(aiStockStem),
+            core: group.rivals.core.map(aiStockStem)
+        });
     }
     if (!broad.length) broad.push(business, craft);
     return {
@@ -462,6 +977,16 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         ].filter((stem)=>stem.length > 1),
         broad: [
             ...new Set(broad.map((query)=>query.trim()).filter(Boolean))
+        ],
+        making: [
+            ...new Set(makingSearches)
+        ],
+        named: [
+            ...new Set(stemList(businessType))
+        ],
+        rivals,
+        core: [
+            ...core
         ]
     };
 }
@@ -474,11 +999,12 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
  * preposition starts the setting, filler dropped, its last three words (the
  * head noun is the last) — else its section's name.
  */ export function aiStockSubjectWords(alt, sectionName) {
-    for (const clause of alt.toLowerCase().split(CLAUSE_BREAK)){
+    // "Hand-poured", "by hand" and "hands" say how it was made, never what it shows.
+    for (const clause of withoutHands(alt).split(CLAUSE_BREAK)){
         const found = subjectOf(contentWords(clause != null ? clause : ''));
         if (found.length) return found.slice(-3).join(' ');
     }
-    return subjectOf(contentWords(sectionName)).slice(0, 2).join(' ');
+    return subjectOf(contentWords(withoutHands(sectionName))).slice(0, 2).join(' ');
 }
 /**
  * The thing a subject shows, one singular word: its last word that is not
@@ -499,16 +1025,54 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     if (aspect < 0.87) return 'vertical';
     return 'any';
 }
+/**
+ * A slot's part (AGL-3660): a tile of a collections band is product-like,
+ * held to the shop's category and its own object; a picture of a story of
+ * the craft, or of a thing made by hand, shows the maker at work.
+ */ export function aiStockSlotPart(slot, sectionName) {
+    if (slot.role === 'hero') return undefined;
+    if (slot.role === 'gallery' && aiStorefrontSays('collections', sectionName)) return 'collection';
+    if (aiStorefrontSays('story', sectionName) || saysMadeByHand(slot.alt) || saysMadeByHand(sectionName)) return 'story';
+    return undefined;
+}
+/** 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".
- */ export function aiStockProductSearches(slot, craft) {
-    var _ref;
+ * 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 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".
+ *
+ * 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' ? {
@@ -517,38 +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 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 raw of (_ref = (_slot_product = slot.product) == null ? void 0 : _slot_product.subjects) != null ? _ref : []){
-        const subject = aiStockSubjectWords(raw, '');
-        if (!subject) continue;
-        const says = craftStems.every((stem)=>stemList(subject).includes(stem));
+    for (const subject of subjects){
+        const stems = stemList(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: craft && !says ? `${craft} ${subject}` : subject,
-            subject
+            query,
+            subject,
+            object,
+            lead: true
         });
     }
-    if (craft) queries.push({
+    // 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,
+        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: craft
+        subject: own || 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
-        }, craft ? {
+        }, entry.lead ? {
+            lead: true
+        } : {
+            leadWorld: true
+        }, entry.object ? {
+            object: entry.object
+        } : {}, 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) {
+/** The searches a slot tries, in order, most specific first, each distinct. */ export function aiStockSearchesFor(slot, terms, subject, part) {
+    var _terms_core, _terms_making;
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
         minWidth: 1600
@@ -560,13 +1217,50 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     const domain = new Set(terms.domain);
     const object = aiStockObjectWord(subject);
     const subjectStems = stemList(subject);
+    const kin = object ? objectKin(object, [
+        ...terms.domain,
+        ...subjectStems
+    ]) : null;
+    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;
-    const broad = terms.broad.map((query)=>({
+    // 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
+    // the category's world alone (AGL-3660).
+    const collection = part === 'collection' && Boolean(terms.craft);
+    const broad = kin && collection ? [] : terms.broad.map((query)=>({
             query,
-            broad: true
+            broad: true,
+            category: collection
+        }));
+    // The maker at work, held to the craft: never "hands" (AGL-3660).
+    const making = ((_terms_making = terms.making) != null ? _terms_making : []).map((query)=>({
+            query,
+            broad: true,
+            category: true
         }));
+    const thing = subject ? [
+        {
+            query: qualify(subject),
+            held: true
+        },
+        ...kin ? kin.queries.map((query)=>({
+                query,
+                held: true
+            })) : [
+            {
+                query: qualify(object),
+                held: true
+            }
+        ]
+    ] : [];
     const queries = slot.role === 'hero' ? [
         {
             query: terms.business,
@@ -574,6 +1268,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         },
         ...broad
     ] : slot.role === 'about' ? [
+        ...part === 'story' ? making : [],
         {
             query: `${terms.business} ${subject}`,
             broad: true,
@@ -584,16 +1279,13 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             broad: true,
             people: true
         },
+        ...part === 'story' ? [] : making,
         ...broad
-    ] : subject ? [
-        {
-            query: qualify(subject)
-        },
-        {
-            query: qualify(object)
-        },
+    ] : [
+        ...part === 'story' ? making : [],
+        ...thing,
         ...broad
-    ] : broad;
+    ];
     const seen = new Set();
     const searches = [];
     for (const raw of queries){
@@ -601,6 +1293,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         const key = `${query}|${raw.people === true}`;
         if (!query || seen.has(key)) continue;
         seen.add(key);
+        const held = raw.held === true && (collection || kinPhrases.length > 0);
         searches.push(_extends({
             query,
             orientation
@@ -608,6 +1301,19 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             people: true
         } : {}, raw.broad ? {
             broad: true
+        } : {}, held && kinPhrases.length ? {
+            kin: kinPhrases
+        } : {}, held && collection ? {
+            lead: true
+        } : {}, 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;
@@ -622,7 +1328,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;
+    var _photo_tags, _photo_alt, _photo_alt1, _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([
@@ -639,17 +1345,42 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         stemList((_photo_alt1 = photo.alt) != null ? _photo_alt1 : '').join(' '),
         stemList(slug).join(' ')
     ];
+    const leadPhrases = [
+        ...tags.slice(0, 3).map((tag)=>stemList(tag).join(' ')),
+        stemList(slug).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([
+        ...tags,
+        ((_photo_alt2 = photo.alt) != null ? _photo_alt2 : '').toLowerCase()
+    ].join(' ').split(/[^a-zÀ-ɏ-]+/).filter((word)=>word.length > 1).map(aiStockStem));
     return {
         lead,
         all,
         phrases,
-        rejected
+        leadPhrases,
+        rejected,
+        words
     };
 }
+/** Whether a phrase is among a hit's phrases, word for word. */ const among = (phrases, phrase)=>phrases.some((found)=>` ${found} `.includes(` ${phrase} `));
+/**
+ * Whether a hit carries a topic its site never named ({@link SENSITIVE_TOPICS}):
+ * a cross, a grave, a flag, a gun, a glass of wine, a child, a mannequin.
+ */ export function aiStockSensitive(photo, named = []) {
+    const { words: found } = hitWords(photo);
+    const site = new Set(named);
+    return SENSITIVE_STEMS.some((topic)=>[
+            ...topic.words
+        ].some((word)=>found.has(word)) && ![
+            ...topic.allow
+        ].some((word)=>site.has(word)));
+}
 /**
  * How well a hit shows what a slot needs (AGL-3660), or 0 when it must not
- * fill it: a mockup or a blank never; a picture of a thing only when the hit
+ * fill it: a mockup or a blank never; a topic the site never named never
+ * ({@link aiStockSensitive}); a picture of a thing only when the hit
  * names its object AND either the site's world or the subject's own
  * two-word phrase ("bud vase", "wick trimmer"); anything else only when it
  * names the site's world (when the site names one). Among the accepted, the
@@ -657,25 +1388,48 @@ 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_requires, _judgement_subject, _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;
+    // 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 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 : '');
-    if (required.some((stem)=>!hit.all.has(stem))) return 0;
+    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 (demanded && !kinNamed && !meets) return 0;
     const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
-    const object = judgement.subject ? aiStockObjectWord(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 || domain.some((stem)=>hit.all.has(stem));
-    const worldLead = required.length > 0 && required.every((stem)=>hit.lead.has(stem)) || 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) && hit.phrases.some((phrase)=>` ${phrase} `.includes(` ${pair} `));
+    const phrased = Boolean(pair) && among(hit.phrases, pair);
     let score = 0;
     if (judgement.strict && object) {
-        if (!hit.all.has(object)) return 0;
+        // An object with kin is named only by them: "melt" alone is resin art.
+        const named = kin.length ? kinNamed : hit.all.has(object);
+        if (!named) return 0;
+        const leading = kin.length ? kinLead : hit.lead.has(object);
+        // A lifestyle scene whose object is a last tag is not a photo OF it.
+        if (judgement.lead && !leading) return 0;
         if (domain.length && !world && !phrased) return 0;
-        score += hit.lead.has(object) ? 4 : 2;
+        score += leading ? 4 : 2;
+        if (kinNamed) score += 3;
     } else if (domain.length) {
         if (!world) return 0;
     }
@@ -793,6 +1547,11 @@ const EXTENSIONS = {
             delete request.broad;
             delete request.subject;
             delete request.requires;
+            delete request.object;
+            delete request.kin;
+            delete request.lead;
+            delete request.leadWorld;
+            delete request.category;
             const key = JSON.stringify([
                 request.query,
                 request.orientation,
@@ -811,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;
@@ -822,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,
@@ -885,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 = [];
@@ -894,26 +1697,33 @@ const EXTENSIONS = {
                 choices.push(null);
                 continue;
             }
-            const subject = aiStockSubjectWords(slot.alt, (_input_sectionNames_slot_sectionIndex = input.sectionNames[slot.sectionIndex]) != null ? _input_sectionNames_slot_sectionIndex : '');
+            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) : aiStockSearchesFor(slot, terms, subject);
-            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
-                }, request.requires ? {
-                    requires: request.requires
-                } : {}));
+                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));
@@ -922,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];
@@ -934,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;
     };
 }