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

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

@@ -26,59 +26,337 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
  * server door (`core.media-ingest`), and builds no source at all when either
  * is missing, so a deployment without a key behaves exactly as before.
  *
- * For each slot, in document order:
+ * What the live starts of 2026-10-10 taught (Juniper Clay Works, a ceramic
+ * artist's portfolio, and Willow Wick Candles, a candle store), each photo
+ * traced through the library's cached answers:
  *
- * 1. **Search.** Plain words. The hero asks for the kind of business (the
- *    head of the site's business type, "yoga studio" from "a family-owned
- *    yoga studio in Austin"). Any other picture asks for its SUBJECT: the
- *    noun phrase that opens the alt text the model wrote, its filler
- *    adjectives dropped ("serving bowl" from "A beautiful hand-thrown serving
- *    bowl on a linen cloth"), qualified by the site's craft where the phrase
- *    does not already say it ("serving bowl ceramic" for a ceramics studio).
- *    An about picture asks for people. The orientation and a minimum size
- *    come from the slot's frame. The provider caches every search for a day
- *    and keeps its own rate limit; one page never asks the same words twice.
- * 2. **Rank.** A picture of a thing must show the thing: every hit is scored
- *    by how many of the subject's words its tags, its description and its
- *    page's address name (singular and plural alike, the head noun counting
- *    double), and a hit naming none of them never fills a picture of a
- *    thing. The live Juniper Clay start put crackers under "Serving bowl"
- *    and plants under "Espresso cup". Among the best-scored hits the job's
- *    seed picks, so two sites built from the same words rarely open with the
- *    same photo while one job always picks the same.
- * 3. **Never twice.** A photo is placed once per job: not twice on a page,
+ * - The site's words were read as "portfolio" and "online" — the kind of
+ *   SITE, not the craft — so every search said "serving bowl portfolio" and
+ *   the hero asked for "portfolio": a wallet, fashion models, and a blank
+ *   paper mockup that read as an empty panel beside the brushes.
+ * - A hit naming the object anywhere won: a robin tagged "food bowl" filled
+ *   "Speckled serving bowl", a lilac branch tagged "bud, vase" filled "Tall
+ *   bud vase", letterpress type tagged "set" filled "Nesting bowl set" (its
+ *   head noun was read as "set"), and an antique tea set tagged "brown
+ *   candle" filled "Candle Gift Set".
+ * - The page's 20 seconds ran out after four photos (each copy took ~5s, one
+ *   after another), and the slots left took the starter photos: the laptop
+ *   desk with pink roses under "Candle Wick Trimmer" and a work card, and the
+ *   windowsill plants under another.
+ *
+ * So, for each slot:
+ *
+ * 1. **The site's terms** ({@link aiStockSiteTerms}): the business is the
+ *    first clause of its type that says more than what kind of site it is
+ *    ("ceramic artist" from "a portfolio for a ceramic artist who makes
+ *    stoneware bowls"), its craft one word ("ceramic"), and its DOMAIN the
+ *    words a photo of its world names: the craft, the business type's own
+ *    nouns ("stoneware", "soy") and, for common crafts, their kin ("pottery",
+ *    "clay", "wax"). Its broad searches ask for the world itself ("handmade
+ *    ceramics", "pottery").
+ * 2. **Search.** A picture of a thing asks for its subject — the noun phrase
+ *    of the caption, filler dropped — qualified by the craft where it does
+ *    not already name the domain ("ceramic serving bowl"), then the craft and
+ *    the object alone ("ceramic bowl"), then the broad searches. A hero asks
+ *    for the business, then broad; an about picture for the business's
+ *    people, then broad. The orientation and a minimum size come from the
+ *    slot's frame.
+ * 3. **Accept, or reject.** A hit tagged as a mockup, a blank or a template
+ *    never fills anything. A picture of a thing takes only a hit naming its
+ *    OBJECT (the head noun, past "set", "gift", "kit": "bowl" in "nesting
+ *    bowl set", "candle" in "candle gift set") AND either the site's domain
+ *    or the subject's own two-word phrase ("bud vase"). A broad, hero or
+ *    about search takes only a hit naming the domain. The accepted are
+ *    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.
+ * 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 maker's portrait in About is
- *    never a vase in Selected work. The caller hands in what the job's other
- *    pages hold (`avoid`); a pass repeated over its own page keeps its own.
- * 4. **Fall back.** A picture of a thing nothing relevant answered asks once
- *    more for the place itself ("ceramics studio interior"), a neutral photo
- *    any caption sits under, before it is left to a starter photo.
- * 5. **Keep.** A photo the site's library already holds (by its source key)
- *    is reused; otherwise its bytes are downloaded from the library and
- *    stored in the site's own media library as the member who started the
- *    job, credited to its photographer. The page names the site's asset,
- *    never the library's address.
+ *    of the same job already placed it. The caller hands in what the job's
+ *    other pages hold (`avoid`); a pass repeated over its own page keeps its
+ *    own.
+ * 5. **Keep, all at once.** The choosing is done first, slot by slot; the
+ *    copies then run side by side, a few at a time, so a page of eight
+ *    pictures takes about as long as two. A photo the site's library already
+ *    holds (by its source key) is reused; otherwise its bytes are copied
+ *    into the site's own library as the member who started the job, credited
+ *    to its photographer. A copy that fails tries the slot's next accepted
+ *    hit.
  *
- * A slot that finds nothing, any error, a refusal from the library (its
- * storage band, say) or the time running out leaves the slot to a starter
- * photo. Nothing here throws, and none of it is an AI model call: photos cost
- * no AI credits.
- */ /** Wall clock the whole page's photos may take, inside the step's own signal. */ export const AI_LAYOUT_STOCK_PHOTOS_BUDGET_MS = 20000;
-/** Searches one page may send to the provider; a repeated query is answered from the page's own memory. */ export const AI_LAYOUT_STOCK_SEARCHES_PER_PAGE = 12;
-/** The hits a pick is made among. */ export const AI_LAYOUT_STOCK_PICK_WINDOW = 8;
-/** The ranked hits one search may try to place before the slot moves to its next search. */ const AI_LAYOUT_STOCK_TRIES_PER_SEARCH = 3;
+ * 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
+ * broad searches come first. Nothing here throws, and none of it is an AI
+ * model call: photos cost no AI credits.
+ */ /** Wall clock the whole page's photos may take, inside the step's own signal. */ export const AI_LAYOUT_STOCK_PHOTOS_BUDGET_MS = 30000;
+/** Searches one page may send to the provider; a repeated query is answered from the page's own memory. */ export const AI_LAYOUT_STOCK_SEARCHES_PER_PAGE = 18;
+/** The hits a pick is made among. */ export const AI_LAYOUT_STOCK_PICK_WINDOW = 40;
+/** The accepted hits a slot keeps in hand, in case a copy fails. */ const AI_LAYOUT_STOCK_TRIES_PER_SLOT = 3;
+/** Copies made side by side. */ const AI_LAYOUT_STOCK_COPIES_AT_ONCE = 4;
 /** The largest photo copied: inside one direct upload. */ export const AI_LAYOUT_STOCK_MAX_BYTES = 3 * 1024 * 1024;
 /**
  * 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';
-/** Words that carry no subject. */ const STOPWORDS = new Set(('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 shop services service site website page photo picture image showing shows show ' + 'someone people person one two three some many several').split(' '));
+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 = new Set(('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 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 ' + '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').split(' '));
-/** The nouns that name a place of business, not its craft: "studio" in "ceramics studio". */ const VENUES = new Set(('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').split(' '));
+ */ 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');
+/** 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');
+/** Verbs a business type uses to say what it does; what follows them is its domain, never its business. */ const DOING = /(?<![\w-])(?:makes?|making|made|sells?|selling|sold|offers?|offering|creates?|creating|specializ(?:es|ing)|specialis(?:es|ing)|provides?|providing|featuring|showcasing)(?![\w-])/g;
+/** Where a business type's own clause ends. */ const BUSINESS_BREAK = /[,;:.()]|\s[-–—]\s|\b(?:in|for|near|serving|based|located|that|which|who|with|from|since|and|&)\b/;
+/** A clause after one of these says where or for whom, never what: "in Austin", "for busy parents". */ const PLACE_OR_AUDIENCE = /^(?:in|near|serving|based|located|across|around|throughout|for)$/;
+/**
+ * Words naming a set or a wrapper of a thing, never the thing: the OBJECT
+ * of "nesting bowl set" is the bowl, of "candle gift set" the candle.
+ */ const WRAPPERS = words('set sets kit kits gift gifts bundle bundles pack packs box boxes trio duo pair collection sampler assortment ' + 'series range line group lot bunch');
+/**
+ * A hit tagged with any of these is never placed: a mockup's blank panel is
+ * 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');
+/**
+ * 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
+ * still has its own words; this only widens what counts as its world.
+ */ const CRAFT_KIN = [
+    {
+        match: [
+            'ceramic',
+            'ceramics',
+            'pottery',
+            'potter',
+            'stoneware',
+            'porcelain',
+            'earthenware',
+            'clay'
+        ],
+        kin: [
+            'ceramic',
+            'ceramics',
+            'pottery',
+            'potter',
+            'stoneware',
+            'porcelain',
+            'earthenware',
+            'clay',
+            'glaze',
+            'kiln'
+        ],
+        broad: [
+            'handmade ceramics',
+            'pottery'
+        ]
+    },
+    {
+        match: [
+            'candle',
+            'candlemaker',
+            'candlemaking'
+        ],
+        kin: [
+            'candle',
+            'candlelight',
+            'wax',
+            'soy',
+            'wick',
+            'scented',
+            'votive',
+            'candlestick'
+        ],
+        broad: [
+            'handmade candles',
+            'scented candles'
+        ]
+    },
+    {
+        match: [
+            'jewelry',
+            'jewellery',
+            'jeweler',
+            'jeweller',
+            'silversmith',
+            'goldsmith'
+        ],
+        kin: [
+            'jewelry',
+            'jewellery',
+            'ring',
+            'necklace',
+            'earring',
+            'bracelet',
+            'silver',
+            'gold',
+            'gemstone'
+        ],
+        broad: [
+            'handmade jewelry',
+            'jewelry'
+        ]
+    },
+    {
+        match: [
+            'soap',
+            'soapmaker',
+            'skincare'
+        ],
+        kin: [
+            'soap',
+            'skincare',
+            'lotion',
+            'bath',
+            'spa',
+            'natural',
+            'cosmetic'
+        ],
+        broad: [
+            'handmade soap',
+            'natural skincare'
+        ]
+    },
+    {
+        match: [
+            'wood',
+            'woodwork',
+            'woodworking',
+            'woodworker',
+            'carpenter',
+            'carpentry',
+            'furniture',
+            'joinery'
+        ],
+        kin: [
+            'wood',
+            'wooden',
+            'woodwork',
+            'timber',
+            'furniture',
+            'carpentry',
+            'oak',
+            'walnut'
+        ],
+        broad: [
+            'woodworking',
+            'wooden furniture'
+        ]
+    },
+    {
+        match: [
+            'bakery',
+            'baker',
+            'bread',
+            'pastry',
+            'cake',
+            'patisserie'
+        ],
+        kin: [
+            'bakery',
+            'bread',
+            'pastry',
+            'cake',
+            'baking',
+            'baked',
+            'dough',
+            'croissant'
+        ],
+        broad: [
+            'bakery',
+            'fresh bread'
+        ]
+    },
+    {
+        match: [
+            'coffee',
+            'cafe',
+            'café',
+            'roaster',
+            'espresso'
+        ],
+        kin: [
+            'coffee',
+            'cafe',
+            'espresso',
+            'latte',
+            'cappuccino',
+            'barista',
+            'beans'
+        ],
+        broad: [
+            'coffee shop',
+            'coffee'
+        ]
+    },
+    {
+        match: [
+            'florist',
+            'flower',
+            'floral'
+        ],
+        kin: [
+            'flower',
+            'floral',
+            'bouquet',
+            'florist',
+            'bloom',
+            'blossom'
+        ],
+        broad: [
+            'florist',
+            'flower bouquet'
+        ]
+    },
+    {
+        match: [
+            'knit',
+            'knitting',
+            'yarn',
+            'weaving',
+            'weaver',
+            'textile',
+            'textiles',
+            'quilt',
+            'quilting',
+            'sewing'
+        ],
+        kin: [
+            'knit',
+            'knitting',
+            'yarn',
+            'wool',
+            'weaving',
+            'textile',
+            'fabric',
+            'quilt',
+            'sewing'
+        ],
+        broad: [
+            'handmade textiles',
+            'yarn'
+        ]
+    },
+    {
+        match: [
+            'leather',
+            'leatherwork',
+            'leathercraft'
+        ],
+        kin: [
+            'leather',
+            'wallet',
+            'bag',
+            'belt',
+            'stitching'
+        ],
+        broad: [
+            'leather craft',
+            'leather goods'
+        ]
+    }
+];
 /** Lowercase words, letters only, without stopwords. */ function contentWords(text) {
     return text.toLowerCase().replace(/https?:\/\/\S+|\S+@\S+|\+?\d[\d\s().-]{5,}\d/g, ' ').replace(/[^a-zÀ-ɏ\s-]/g, ' ').split(/\s+/).map((word)=>word.replace(/^-+|-+$/g, '')).filter((word)=>word.length > 1 && !STOPWORDS.has(word));
 }
@@ -93,35 +371,102 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
     if (lower.length > 3 && lower.endsWith('s') && !/(?:ss|us|is)$/.test(lower)) return lower.slice(0, -1);
     return lower;
 }
-/** A text's words as stems; a hyphenated word counts as its parts. */ function stems(text) {
-    const out = new Set();
-    for (const word of text.toLowerCase().split(/[^a-zÀ-ɏ]+/)){
-        if (word.length > 1) out.add(aiStockStem(word));
-    }
-    return out;
+/** A text's words as stems, in order; a hyphenated word counts as its parts. */ function stemList(text) {
+    return text.toLowerCase().split(/[^a-zÀ-ɏ]+/).filter((word)=>word.length > 1).map(aiStockStem);
 }
 /** Where a noun phrase ends: punctuation, a preposition, a conjunction. */ const CLAUSE_BREAK = /[,;:.()]|\s[-–—]\s|\b(?:with|on|in|at|against|beside|next|near|under|over|by|from|for|during|while|atop|inside|across|beneath|through|into|onto|amid|among|and|of|that|which|who)\b|&/;
+/** A business type's clauses, each with the word that opened it. */ function businessClauses(businessType) {
+    const text = businessType.toLowerCase().replace(DOING, ' | ');
+    const clauses = [];
+    const breaker = new RegExp(`${BUSINESS_BREAK.source}|\\|`, 'g');
+    let at = 0;
+    let opener = '';
+    for (const match of text.matchAll(breaker)){
+        var _match_index;
+        clauses.push({
+            opener,
+            words: contentWords(text.slice(at, match.index))
+        });
+        opener = match[0].trim();
+        at = ((_match_index = match.index) != null ? _match_index : 0) + match[0].length;
+    }
+    clauses.push({
+        opener,
+        words: contentWords(text.slice(at))
+    });
+    return clauses;
+}
+/** A clause's words that name the business: no site kind, no filler. */ const businessOf = (clause)=>clause.filter((word)=>!SITE_KINDS.has(word) && !FILLER.has(word));
 /**
  * The kind of business in a few words: the first clause of the business
- * type, before a place or an audience, its last three content words (the
- * head of an English noun phrase is at its end).
+ * type that says more than what kind of site it is, before a place, an
+ * audience or what it makes, filler dropped, its last three words (the head
+ * of an English noun phrase is at its end). "ceramic artist" from "a
+ * portfolio for a ceramic artist who makes stoneware bowls"; "candle shop"
+ * from "a small-batch candle shop selling hand-poured soy candles online".
  */ export function aiStockBusinessWords(businessType) {
-    const clause = businessType.toLowerCase().split(/[,;:.()]|\s[-–—]\s|\b(?:in|for|near|serving|based|located|that|which|who|with|from|since|and|&)\b/)[0];
-    const words = contentWords(clause != null ? clause : '');
-    return words.slice(-3).join(' ');
+    for (const { words: clause } of businessClauses(businessType)){
+        const named = businessOf(clause);
+        if (named.length) return named.slice(-3).join(' ');
+    }
+    return '';
 }
 /**
  * The business's craft in one word: the last of its words that is not the
- * place it is done in, singular — "ceramic" from "small-batch ceramics
- * studio", "yoga" from "yoga studio". Empty when the business is only a
- * place ("a shop").
+ * place it is done in nor the person doing it, singular — "ceramic" from
+ * "ceramics studio" or "ceramic artist", "yoga" from "yoga studio". Empty
+ * when the business is only a place ("a shop").
  */ export function aiStockCraftWords(business) {
-    const words = business.split(/\s+/).filter((word)=>word && !VENUES.has(word) && !FILLER.has(word));
-    const craft = words[words.length - 1];
+    const named = business.split(/\s+/).filter((word)=>word && !VENUES.has(word) && !ROLES.has(word) && !FILLER.has(word) && !SITE_KINDS.has(word));
+    const craft = named[named.length - 1];
     return craft ? aiStockStem(craft) : '';
 }
-/** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(words) {
-    return words.filter((word)=>!FILLER.has(word));
+/** The site's terms, read from its business type. */ export function aiStockSiteTerms(businessType) {
+    const business = aiStockBusinessWords(businessType);
+    const craft = aiStockCraftWords(business);
+    const domain = new Set();
+    /** The things it makes, by their head nouns. */ const made = new Set();
+    let named = false;
+    let making = false;
+    for (const { opener, words: clause } of businessClauses(businessType)){
+        if (opener === '|') making = true;
+        // Where it is, and who it is for, are not its world — once something has named it.
+        if (named && PLACE_OR_AUDIENCE.test(opener)) {
+            making = false;
+            continue;
+        }
+        const kept = businessOf(clause).filter((word)=>!VENUES.has(word) && !ROLES.has(word));
+        if (kept.length) named = true;
+        // 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;
+        for (const word of world)for (const stem of stemList(word))domain.add(stem);
+        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 broad = [];
+    for (const group of CRAFT_KIN){
+        if (!group.match.some((word)=>domain.has(aiStockStem(word)) || made.has(aiStockStem(word)))) continue;
+        for (const word of group.kin)domain.add(aiStockStem(word));
+        broad.push(...group.broad);
+    }
+    if (!broad.length) broad.push(business, craft);
+    return {
+        business,
+        craft,
+        domain: [
+            ...domain
+        ].filter((stem)=>stem.length > 1),
+        broad: [
+            ...new Set(broad.map((query)=>query.trim()).filter(Boolean))
+        ]
+    };
+}
+/** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(list) {
+    return list.filter((word)=>!FILLER.has(word));
 }
 /**
  * A picture's subject in a few words (AGL-3660): the noun phrase its alt
@@ -130,19 +475,80 @@ import { aiLayoutSeedNumber } from "../layout-language/ai-layout-pictures.js";
  * head noun is the last) — else its section's name.
  */ export function aiStockSubjectWords(alt, sectionName) {
     for (const clause of alt.toLowerCase().split(CLAUSE_BREAK)){
-        const words = subjectOf(contentWords(clause != null ? clause : ''));
-        if (words.length) return words.slice(-3).join(' ');
+        const found = subjectOf(contentWords(clause != null ? clause : ''));
+        if (found.length) return found.slice(-3).join(' ');
     }
     return subjectOf(contentWords(sectionName)).slice(0, 2).join(' ');
 }
+/**
+ * The thing a subject shows, one singular word: its last word that is not
+ * a set or a wrapper of it — "bowl" from "nesting bowl set", "candle" from
+ * "candle gift set", "vase" from "bud vase". Its last word when every word
+ * is one ("gift set").
+ */ export function aiStockObjectWord(subject) {
+    var _ref, _reverse_find;
+    const list = subject.split(/\s+/).filter(Boolean);
+    const object = (_ref = (_reverse_find = [
+        ...list
+    ].reverse().find((word)=>!WRAPPERS.has(word))) != null ? _reverse_find : list[list.length - 1]) != null ? _ref : '';
+    return object ? aiStockStem(object) : '';
+}
 const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUERY_MAX_CHARS).trim();
 /** The frame's orientation: a wide frame wants a landscape photo, a tall one a portrait. */ export function aiStockOrientation(aspect) {
     if (aspect > 1.15) return 'horizontal';
     if (aspect < 0.87) return 'vertical';
     return 'any';
 }
-/** The searches a slot tries, in order, most specific first, each distinct. */ export function aiStockSearchesFor(slot, words) {
-    var _words_craft;
+/**
+ * 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;
+    var _slot_product;
+    const orientation = aiStockOrientation(slot.aspect);
+    const size = orientation === 'vertical' ? {
+        minHeight: 900
+    } : {
+        minWidth: 900
+    };
+    const craftStems = stemList(craft);
+    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));
+        queries.push({
+            query: craft && !says ? `${craft} ${subject}` : subject,
+            subject
+        });
+    }
+    if (craft) queries.push({
+        query: craft,
+        subject: craft
+    });
+    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);
+        searches.push(_extends({
+            query,
+            orientation
+        }, size, {
+            subject: entry.subject
+        }, craft ? {
+            requires: craft
+        } : {}));
+    }
+    return searches;
+}
+/** The searches a slot tries, in order, most specific first, each distinct. */ export function aiStockSearchesFor(slot, terms, subject) {
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
         minWidth: 1600
@@ -151,107 +557,143 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     } : {
         minWidth: 900
     };
-    const craft = (_words_craft = words.craft) != null ? _words_craft : aiStockCraftWords(words.business);
-    const subjectStems = stems(words.subject);
-    // The craft qualifies a subject that does not already say it.
-    const qualified = craft && [
-        ...stems(craft)
-    ].some((stem)=>!subjectStems.has(stem)) ? `${words.subject} ${craft}` : words.subject;
-    const place = words.business.split(/\s+/).some((word)=>VENUES.has(word)) ? `${words.business} interior` : words.business;
+    const domain = new Set(terms.domain);
+    const object = aiStockObjectWord(subject);
+    const subjectStems = stemList(subject);
+    // The craft qualifies a subject that does not already name the site's world.
+    const namesWorld = subjectStems.some((stem)=>domain.has(stem));
+    const qualify = (phrase)=>terms.craft && !namesWorld && !stemList(phrase).includes(terms.craft) ? `${terms.craft} ${phrase}` : phrase;
+    const broad = terms.broad.map((query)=>({
+            query,
+            broad: true
+        }));
     const queries = slot.role === 'hero' ? [
         {
-            query: words.business
+            query: terms.business,
+            broad: true
         },
-        {
-            query: `${words.business} ${words.subject}`
-        }
+        ...broad
     ] : slot.role === 'about' ? [
         {
-            query: `${words.business} ${words.subject}`
+            query: `${terms.business} ${subject}`,
+            broad: true,
+            people: true
         },
         {
-            query: words.business
-        }
-    ] : words.subject ? [
-        {
-            query: qualified
+            query: terms.business,
+            broad: true,
+            people: true
         },
+        ...broad
+    ] : subject ? [
         {
-            query: words.subject
+            query: qualify(subject)
         },
         {
-            query: place,
-            neutral: true
-        }
-    ] : [
-        {
-            query: place,
-            neutral: true
-        }
-    ];
+            query: qualify(object)
+        },
+        ...broad
+    ] : broad;
     const seen = new Set();
     const searches = [];
     for (const raw of queries){
         const query = clip(raw.query);
-        if (!query || seen.has(query)) continue;
-        seen.add(query);
+        const key = `${query}|${raw.people === true}`;
+        if (!query || seen.has(key)) continue;
+        seen.add(key);
         searches.push(_extends({
             query,
             orientation
-        }, size, slot.role === 'about' ? {
+        }, size, raw.people ? {
             people: true
-        } : {}, raw.neutral ? {
-            neutral: true
+        } : {}, raw.broad ? {
+            broad: true
         } : {}));
     }
     return searches;
 }
-/**
- * How well a hit names a subject (AGL-3660): each subject word its tags, its
- * description or its page's address names counts once, the head noun (the
- * subject's last word) twice, and a craft word a quarter, as a tiebreak.
- * Zero when it names none of the subject.
- */ export function aiStockRelevance(photo, terms) {
-    var _photo_tags, _photo_alt, _terms_craft;
-    const subject = terms.subject.split(/\s+/).filter(Boolean).map(aiStockStem);
-    if (!subject.length) return 0;
-    let slug;
+/** The words of a photo's page address at its library, its id dropped: "robin-bird-songbird-garden-winter". */ function pageSlug(pageUrl) {
     try {
-        slug = new URL(photo.pageUrl).pathname;
+        var _ref;
+        const last = decodeURIComponent(new URL(pageUrl).pathname).split('/').filter(Boolean).pop();
+        return (_ref = last == null ? void 0 : last.replace(/-?\d+$/, '')) != null ? _ref : '';
     } catch (unused) {
-        slug = '';
+        return '';
     }
-    const named = stems([
-        ...(_photo_tags = photo.tags) != null ? _photo_tags : [],
+}
+/** 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;
+    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([
+        ...tags.slice(0, 3),
+        slug
+    ].join(' ')));
+    const all = new Set(stemList([
+        ...tags,
         (_photo_alt = photo.alt) != null ? _photo_alt : '',
         slug
-    ].join(' '));
-    const head = subject[subject.length - 1];
+    ].join(' ')));
+    const phrases = [
+        ...tags.map((tag)=>stemList(tag).join(' ')),
+        stemList((_photo_alt1 = photo.alt) != null ? _photo_alt1 : '').join(' '),
+        stemList(slug).join(' ')
+    ];
+    const rejected = tags.some((tag)=>REJECTED_TAGS.has(tag) || tag.split(/\s+/).some((word)=>REJECTED_TAGS.has(word)));
+    return {
+        lead,
+        all,
+        phrases,
+        rejected
+    };
+}
+/**
+ * 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
+ * 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
+ * object among the hit's first tags counts 4 (a mention among its last, 2),
+ * 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;
+    const hit = hitWords(photo);
+    if (hit.rejected) return 0;
+    const required = stemList((_judgement_requires = judgement.requires) != null ? _judgement_requires : '');
+    if (required.some((stem)=>!hit.all.has(stem))) return 0;
+    const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
+    const 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 pair = subject.length >= 2 ? subject.slice(-2).join(' ') : '';
+    const phrased = Boolean(pair) && hit.phrases.some((phrase)=>` ${phrase} `.includes(` ${pair} `));
     let score = 0;
-    for (const word of new Set(subject)){
-        if (named.has(word)) score += word === head ? 2 : 1;
-    }
-    if (score === 0) return 0;
-    for (const word of new Set(((_terms_craft = terms.craft) != null ? _terms_craft : '').split(/\s+/).filter(Boolean).map(aiStockStem))){
-        if (named.has(word)) score += 0.25;
+    if (judgement.strict && object) {
+        if (!hit.all.has(object)) return 0;
+        if (domain.length && !world && !phrased) return 0;
+        score += hit.lead.has(object) ? 4 : 2;
+    } else if (domain.length) {
+        if (!world) return 0;
     }
-    return score;
+    if (phrased) score += 3;
+    for (const word of new Set(subject))if (word !== object && hit.all.has(word)) score += 1;
+    if (world) score += worldLead ? 1.25 : 1;
+    return Math.max(score, 0.5);
 }
 /**
- * A search's hits in the order they are tried (AGL-3660): those not placed
- * yet, among the first few, best-scored first; the seed turns the hits that
- * score alike, so two jobs differ and one job repeats itself.
- */ export function aiStockRank(photos, used, seed, options = {}) {
-    var _options_subject;
-    const subject = (_options_subject = options.subject) != null ? _options_subject : '';
+ * A search's acceptable hits in the order they are tried (AGL-3660): those
+ * not placed yet, among the first few the library returned, those it must
+ * not take dropped ({@link aiStockRelevance}), best first; the seed turns
+ * the hits that score alike, so two jobs differ and one job repeats itself.
+ */ export function aiStockRank(photos, used, seed, judgement = {}) {
     const scored = photos.filter((photo)=>!used.has(stockPhotoSourceKey(photo))).slice(0, AI_LAYOUT_STOCK_PICK_WINDOW).map((photo)=>({
             photo,
-            score: subject ? aiStockRelevance(photo, _extends({
-                subject
-            }, options.craft ? {
-                craft: options.craft
-            } : {})) : 0
-        })).filter((entry)=>!options.strict || !subject || entry.score > 0);
+            score: aiStockRelevance(photo, judgement)
+        })).filter((entry)=>entry.score > 0);
     if (!scored.length) return [];
     const turn = aiLayoutSeedNumber(seed);
     const ranked = [];
@@ -267,9 +709,9 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     }
     return ranked;
 }
-/** The pick among a search's hits: the first {@link aiStockRank} would try, or `null`. */ export function aiStockPick(photos, used, seed, options = {}) {
+/** The pick among a search's hits: the first {@link aiStockRank} would try, or `null`. */ export function aiStockPick(photos, used, seed, judgement = {}) {
     var _aiStockRank_;
-    return (_aiStockRank_ = aiStockRank(photos, used, seed, options)[0]) != null ? _aiStockRank_ : null;
+    return (_aiStockRank_ = aiStockRank(photos, used, seed, judgement)[0]) != null ? _aiStockRank_ : null;
 }
 /**
  * The library photos a stored page already shows: every `image` whose
@@ -323,8 +765,7 @@ const EXTENSIONS = {
     const provider = ((_deps_provider = deps.provider) != null ? _deps_provider : stockPhotoProvider)();
     const ingest = ((_deps_ingest = deps.ingest) != null ? _deps_ingest : pluginMediaIngest)();
     if (!provider || !ingest || !input.hostId || !input.uid) return null;
-    const business = aiStockBusinessWords(input.business);
-    const craft = aiStockCraftWords(business);
+    const terms = aiStockSiteTerms(input.business);
     return async (slots)=>{
         var _deps_budgetMs, _input_avoid;
         const timeout = AbortSignal.timeout((_deps_budgetMs = deps.budgetMs) != null ? _deps_budgetMs : AI_LAYOUT_STOCK_PHOTOS_BUDGET_MS);
@@ -336,7 +777,7 @@ const EXTENSIONS = {
         const job = jobPhotos(input.jobId ? `${input.hostId}:${input.jobId}` : null);
         const avoid = new Set((_input_avoid = input.avoid) != null ? _input_avoid : []);
         /** Placed elsewhere in the job: by another page in this process, or one the caller read. */ const elsewhere = (key)=>avoid.has(key) || (job == null ? void 0 : job.has(key)) === true && job.get(key) !== scope;
-        /** Source keys this page has placed or turned down. */ const used = new Set();
+        /** Source keys this page has claimed for a slot, or turned down. */ const claimed = new Set();
         /** Asset srcs this page has placed. */ const placedSrcs = new Set();
         const answers = new Map();
         let searches = 0;
@@ -346,9 +787,12 @@ const EXTENSIONS = {
             job == null ? void 0 : job.set(sourceKey, scope);
             job == null ? void 0 : job.set(src, scope);
         };
-        /** A search's hits; the same words twice are answered from memory, and `null` once the page's searches are spent. */ const search = async (wanted)=>{
+        /** A search's hits; the same words twice are answered from memory, and `null` once the page's searches are spent. */ const search = (wanted)=>{
+            var _input_searches;
             const request = _extends({}, wanted);
-            delete request.neutral;
+            delete request.broad;
+            delete request.subject;
+            delete request.requires;
             const key = JSON.stringify([
                 request.query,
                 request.orientation,
@@ -356,24 +800,19 @@ const EXTENSIONS = {
             ]);
             const known = answers.get(key);
             if (known) return known;
-            if (searches >= AI_LAYOUT_STOCK_SEARCHES_PER_PAGE) return null;
+            if (searches >= ((_input_searches = input.searches) != null ? _input_searches : AI_LAYOUT_STOCK_SEARCHES_PER_PAGE)) return Promise.resolve(null);
             searches += 1;
-            let found;
-            try {
+            const asked = provider.search(request, {
+                signal
+            }).then((found)=>{
                 var _ref;
-                var _this;
-                found = (_ref = (_this = await provider.search(request, {
-                    signal
-                })) == null ? void 0 : _this.photos) != null ? _ref : [];
-            } catch (unused) {
-                found = [];
-            }
-            answers.set(key, found);
-            return found;
+                return (_ref = found == null ? void 0 : found.photos) != null ? _ref : [];
+            }).catch(()=>[]);
+            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)=>{
             const sourceKey = stockPhotoSourceKey(photo);
-            used.add(sourceKey);
             try {
                 var _EXTENSIONS_bytes_contentType;
                 const kept = await ingest.findStockPhoto({
@@ -393,12 +832,12 @@ const EXTENSIONS = {
                 }
                 // A refusal to store (the storage band, a lockdown) holds for the
                 // whole page, so the rest of it reuses what it can and copies nothing.
-                if (!storing) return null;
+                if (!storing || signal.aborted) return null;
                 const bytes = await provider.download(photo, {
                     maxBytes: AI_LAYOUT_STOCK_MAX_BYTES,
                     signal
                 });
-                if (!bytes || signal.aborted) return null;
+                if (!bytes || signal.aborted || !storing) return null;
                 const credit = provider.credit(photo);
                 const stored = await ingest.ingest({
                     hostId: input.hostId,
@@ -446,43 +885,77 @@ const EXTENSIONS = {
             }
             return null;
         };
-        const photos = [];
+        // 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 = [];
         for (const [index, slot] of slots.entries()){
             var _input_sectionNames_slot_sectionIndex;
             if (signal.aborted) {
-                photos.push(null);
+                choices.push(null);
                 continue;
             }
             const subject = aiStockSubjectWords(slot.alt, (_input_sectionNames_slot_sectionIndex = input.sectionNames[slot.sectionIndex]) != null ? _input_sectionNames_slot_sectionIndex : '');
-            let placed = null;
-            for (const request of aiStockSearchesFor(slot, {
-                business,
-                subject,
-                craft
-            })){
-                if (placed || signal.aborted) break;
+            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 found = await search(request);
                 if (found === null) break;
-                // A gallery picture names a thing, and only a hit naming it fills it;
-                // a hero, an about picture and the neutral search rank, unfiltered.
-                const blocked = new Set(used);
+                const blocked = new Set(claimed);
                 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}`, {
-                    subject: request.neutral ? craft || business : subject,
-                    craft,
-                    strict: slot.role === 'gallery' && !request.neutral
-                });
-                for (const photo of ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SEARCH)){
-                    if (signal.aborted) break;
-                    placed = await keep(photo, slot, request.query);
-                    if (placed) break;
-                }
+                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
+                } : {}));
+                if (!ranked.length) continue;
+                const first = ranked[0];
+                claimed.add(stockPhotoSourceKey(first));
+                choice = {
+                    candidates: ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SLOT),
+                    query: request.query
+                };
             }
-            photos.push(placed);
+            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.
+        const photos = slots.map(()=>null);
+        const fill = async (index)=>{
+            const choice = choices[index];
+            const slot = slots[index];
+            if (!choice || !slot) return;
+            for (const [rank, candidate] of choice.candidates.entries()){
+                if (signal.aborted) return;
+                const key = stockPhotoSourceKey(candidate);
+                if (rank > 0) {
+                    if (claimed.has(key)) continue;
+                    claimed.add(key);
+                }
+                const placed = await keep(candidate, slot, choice.query);
+                if (placed) {
+                    photos[index] = placed;
+                    return;
+                }
+            }
+        };
+        let next = 0;
+        const worker = async ()=>{
+            while(next < slots.length){
+                const index = next;
+                next += 1;
+                await fill(index);
+            }
+        };
+        await Promise.all(Array.from({
+            length: Math.min(AI_LAYOUT_STOCK_COPIES_AT_ONCE, slots.length)
+        }, worker));
         return photos;
     };
 }