@aglyn/plugins-ai 1.0.0-beta.285 → 1.0.0-beta.288

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

@@ -1,4 +1,5 @@
 import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
 /**
  * @license
  * Copyright 2026 Aglyn LLC
@@ -140,6 +141,36 @@ import { aiStockBusinessNoun } from "./ai-stock-business-nouns.js";
  *    where this module lists it ("gym" of "Synchronicity Gym"); and a
  *    training word's other senses (a railway's train, an elevator's lift, a
  *    newspaper's press, a boat's row) never fill a gym's picture.
+ * 10. **The trade, never a word of it** (the 2026-10-25 booth kit, AGL-4065:
+ *    six trades whose photos were race cars, cyclists, horses, a Honda
+ *    scooter, a canoe for "Parts for the ranch", hotel buffets for a taco
+ *    trailer and an office for a landscaper). A business named by two
+ *    things ("Motorcycle and dirt bike repair shop") is both; the craft
+ *    named first leads, never one named only in what a customer may ask
+ *    ("takes catering requests"); a hero's first tag and a broad search's
+ *    hit name the business's own world ({@link AiStockSiteTerms.lead}),
+ *    never any word of its type ("race" of "race car"); a two-word world
+ *    ("dirt bike") is named whole; a maker's name never shows; a sentence to
+ *    the reader, a job or an order is never a subject, and a part or gear is
+ *    searched only with its world; a record's cover is searched in its world
+ *    first; and a listed world widens only where the library knew nothing of
+ *    it, never an outdoor or a trade world to an office.
+ * 11. **The thing, the place and the trade** (the 2026-10-28 live check,
+ *    AGL-4092: a bare foot tagged "body part" for a parts shop's "Engine and
+ *    air", a transmission chain for its "Brake Pad Set", a cat tagged "hungry"
+ *    for a taco trailer's "Come hungry", a European alley for "Around town", a
+ *    taco bowl salad for "Race day", and a man posing with a street bike tagged
+ *    "susuki" in a motocross team's band of pictures). A picture of a thing is
+ *    held to the business's own world, never any word of its type; a feeling,
+ *    a time or a way of being somewhere is never a thing, and "around town" is
+ *    the business's customers out there; a broad search's photo is OF the
+ *    world among its first tags, never a "taco bowl"; an animal, a toy or a
+ *    bare body part never leads a photo naming nothing of the world; a trade's
+ *    things are held to the world it serves, never to "part"; a product takes
+ *    a shoot no other product shows; a motocross business's world is
+ *    off-road; and a maker is named one letter off ("susuki") and by its
+ *    gear's and tires' names. Still by the tags: a mark only the pixels show
+ *    is placed.
  *
  * A slot the library could not fill because it never answered — down, or
  * out of time before its first answer — or because the site's library
@@ -211,7 +242,80 @@ import { aiStockBusinessNoun } from "./ai-stock-business-nouns.js";
     });
 }
 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 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 ' + // A sentence to the reader, never what a picture shows (AGL-4065): "Tell us
+// the bike and we will say if it will fit" searched "tell us bike".
+'we us you they them i me if tell say describe send ask need want get let know see find will would could');
+/**
+ * Words of a sentence to the reader that a business type may use as a name
+ * ("IT support", "Fit club", "call center"): never a picture's subject
+ * (AGL-4065), always a business's own word.
+ */ const SENTENCE_WORDS = words('it fit can call');
+/**
+ * Nouns that never stand alone as what a picture shows (AGL-4065): a job, a
+ * request, an order. "Describe your job" searched "handyman describe job" and
+ * placed a job application form; "OEM ATV Parts Order" searched "atv parts
+ * order" and placed trees tagged "order".
+ */ const GENERIC_OBJECTS = words('job jobs request requests order orders service services detail details thing things stuff action cta');
+/**
+ * Things a world has many of, which a photo shows only in that world
+ * (AGL-4065): a part, gear, a machine. Searched only with the site's own
+ * world ("dirt bike parts"), never alone: "parts" answered a canoe on a
+ * river, tagged "part", for a dirt bike shop's "Parts for the ranch".
+ */ const WORLD_OBJECTS = words('part parts gear gears machine machines equipment spare spares accessory accessories');
+/**
+ * Words of a picture's caption that are never the thing it shows (AGL-4092):
+ * a feeling, a time, a way of being somewhere. "Come hungry" read its object
+ * as "hungry" and took a cat tagged "hungry"; "Around town" read "town" and
+ * took a European alley. A caption left with no thing is a picture of the
+ * site's own world. A personal record is a feat, never a thing: "Deadlift PR
+ * night" is of the deadlift.
+ */ const NON_THINGS = words('come hungry happy ready welcome day days night nights time times today tonight weekend weekends season seasons ' + 'around town hours hour way moment moments memories pr pb');
+/**
+ * Where a business is, said as a place to go (AGL-4092): "Around town", "At
+ * events". Never a street of houses: a picture of it shows the business's
+ * customers out where it is, or its stand.
+ */ const PLACE_PHRASES = /\b(?:around town|in town|downtown|on the road|out and about|at (?:the )?events|neighbou?rhoods?)\b/i;
+/** What a picture of a business out where it is shows, as stems: its people, a line, a street stand (AGL-4092). */ const PLACE_NEEDS = [
+    'people',
+    'crowd',
+    'customer',
+    'customers',
+    'queue',
+    'line',
+    'street food',
+    'food truck',
+    'market',
+    'festival'
+];
+/** A street that is someone else's, never where a business is found (AGL-4092): a European alley for "Around town". */ const FOREIGN_STREET = [
+    'alley',
+    'cobblestone',
+    'village',
+    'old town',
+    'historic',
+    'castle',
+    'cathedral',
+    'europe',
+    'landscape',
+    'architecture'
+];
+/**
+ * The verbs a business type's clause opens with when it says what a customer
+ * may ask of it (AGL-4065): "takes quote requests", "books repair
+ * appointments". The verb is never the business's world.
+ */ const TRANSACTION_VERBS = words('take takes taking book books booking accept accepts accepting welcome welcomes');
+/**
+ * What a business does with a customer, never what its photos show
+ * (AGL-4065), as stems: dropped from its world. "Special orders" named
+ * Berm & Bolt's world, so a delivery man's "order" and trees tagged "order"
+ * filled its products.
+ */ const TRANSACTION_STEMS = new Set(// "Takes" and "books" are verbs only where they open a clause (TRANSACTION_VERBS): a bookshop's books are its world.
+'booking appointment order request quote estimate free inquiry pickup special around town'.split(' '));
+/**
+ * Words of a business's own clause that name its world only beside another
+ * (AGL-4065): "race" and "team" of "amateur motocross race team" are a race
+ * car's and an office's as often. Never its own world alone.
+ */ const LEAD_GENERIC = words('amateur pro race racing team club crew group repair repairs service home house food truck trailer mobile ' + 'street event events custom family families');
 /**
  * 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.
@@ -547,6 +651,165 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         ].map(aiStockStem))
     };
 });
+/**
+ * Makers whose names a photo's tags or its page address give, which no
+ * site's pictures carry unless its own words name the maker (AGL-4065): the
+ * Rut Runners Racing heroes were race cars in a pit lane under their makers'
+ * logos, and Holeshot Moto Repair's a Honda scooter and an Indian cruiser. A
+ * name that is also a common word ("apple", "puma", "triumph", "indian") is
+ * named only in the phrase that makes it the maker's. Read from the tags and
+ * the address, so a logo no tag names still shows: the live check is where
+ * that is seen.
+ */ /** The one-word makers of riding gear and tires (AGL-4092), also never said in a photo's description ({@link BRANDS}). */ const GEAR_MAKER_WORDS = [
+    'alpinestars',
+    'oneal',
+    'leatt',
+    'arai',
+    'shoei',
+    'agv',
+    'oakley',
+    'renthal',
+    'fmf',
+    'acerbis',
+    'dunlop',
+    'michelin',
+    'pirelli',
+    'bridgestone',
+    'metzeler',
+    'maxxis',
+    'kenda'
+];
+const MAKERS = [
+    'porsche',
+    'ferrari',
+    'lamborghini',
+    'bmw',
+    'mercedes',
+    'audi',
+    'volkswagen',
+    'vw',
+    'toyota',
+    'honda',
+    'yamaha',
+    'kawasaki',
+    'suzuki',
+    'ktm',
+    'ducati',
+    'harley',
+    'harley-davidson',
+    'husqvarna',
+    'gasgas',
+    'tesla',
+    'ford',
+    'chevrolet',
+    'chevy',
+    'dodge',
+    'jeep',
+    'nissan',
+    'subaru',
+    'mazda',
+    'indian motorcycle',
+    'triumph motorcycle',
+    'gran turismo',
+    'playstation',
+    'xbox',
+    'nintendo',
+    'nike',
+    'adidas',
+    'reebok',
+    'red bull',
+    'monster energy',
+    'coca cola',
+    'cocacola',
+    'pepsi',
+    'iphone',
+    'ipad',
+    'macbook',
+    'imac',
+    'samsung',
+    'starbucks',
+    'mcdonalds',
+    'mcdonald',
+    // A rider's gear and a bike's tires carry their makers' marks as often as
+    // the bike does (AGL-4092). A maker whose name is a common word ("fox",
+    // "shift", "thor", "fly", "bell") is named only in its phrase.
+    ...GEAR_MAKER_WORDS,
+    'fox racing',
+    'shift mx',
+    'shift racing',
+    'thor mx',
+    'fly racing',
+    'troy lee',
+    'bell helmets',
+    'pro taper'
+];
+/** The makers as stems and stem phrases, as a hit's words are read. */ const MAKER_STEMS = new Set(MAKERS.map((maker)=>stemList(maker).join(' ')));
+/**
+ * The one-word makers long enough that a tag one letter off still names them
+ * (AGL-4092): Pixabay's "susuki" is a Suzuki. Never a common word one letter
+ * off a maker: "barley" is not a Harley, nor "rental" a Renthal.
+ */ const FUZZY_MAKERS = [
+    ...MAKER_STEMS
+].filter((maker)=>!maker.includes(' ') && maker.length >= 6);
+/** Words one letter off a maker that are words of their own (AGL-4092). */ const MAKER_LOOKALIKES = words('barley parley harlem rental samsun ducat phone suzuka');
+/** Whether two words are one edit apart: a letter changed, added, dropped, or two side by side swapped. */ function oneEditApart(a, b) {
+    if (a === b) return false;
+    if (Math.abs(a.length - b.length) > 1) return false;
+    if (a.length === b.length) {
+        const differ = [
+            ...a
+        ].flatMap((letter, index)=>letter === b[index] ? [] : [
+                index
+            ]);
+        if (differ.length === 1) return true;
+        const [first, second] = differ;
+        return differ.length === 2 && second === first + 1 && a[first] === b[second] && a[second] === b[first];
+    }
+    const [short, long] = a.length < b.length ? [
+        a,
+        b
+    ] : [
+        b,
+        a
+    ];
+    let index = 0;
+    while(index < short.length && short[index] === long[index])index += 1;
+    return short.slice(index) === long.slice(index + 1);
+}
+/** The maker a word names one letter off, else `null` ({@link FUZZY_MAKERS}). */ function fuzzyMaker(word) {
+    var _FUZZY_MAKERS_find;
+    if (word.length < 5 || MAKER_LOOKALIKES.has(word) || MAKER_STEMS.has(word)) return null;
+    return (_FUZZY_MAKERS_find = FUZZY_MAKERS.find((maker)=>oneEditApart(word, maker))) != null ? _FUZZY_MAKERS_find : null;
+}
+/**
+ * A phrase's words and each pair of them in turn, as stems (AGL-4065): "dirt
+ * bike" names the motocross world where "bike" alone names a bicycle's too.
+ */ function withPairs(list) {
+    const out = [
+        ...list
+    ];
+    for(let index = 0; index + 1 < list.length; index += 1)out.push(`${list[index]} ${list[index + 1]}`);
+    return out;
+}
+/** A text's stems and stem pairs, every tag or phrase read on its own. */ function termsOf(texts) {
+    return new Set(texts.flatMap((text)=>withPairs(stemList(text))));
+}
+/** A word or phrase as stems: "dirt bikes" is "dirt bike". */ const stemPhrase = (phrase)=>stemList(phrase).join(' ');
+/**
+ * A tag that says what a photo suits, never what it shows (AGL-4065):
+ * "samsung wallpaper", "iphone wallpaper", "lock screen". A latte tagged so
+ * shows no phone.
+ */ const SUITS = /\b(?:wallpapers?|backgrounds?|screens?|screensavers?|lockscreen|4k|hd)\b/i;
+/** The words a photo names a maker by: its tags, those of what it suits left out, its description and its page address. */ function aiStockMakerTerms(photo) {
+    var _photo_tags, _photo_alt;
+    const tags = ((_photo_tags = photo.tags) != null ? _photo_tags : []).filter((tag)=>!SUITS.test(tag));
+    // "O'Neal" is one name, never "neal" (AGL-4092).
+    return termsOf([
+        ...tags,
+        (_photo_alt = photo.alt) != null ? _photo_alt : '',
+        pageSlug(photo.pageUrl)
+    ].map((text)=>text.replace(/['’]/g, '')));
+}
 /**
  * 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
@@ -735,11 +998,216 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'cream jar',
             'moisturizer'
         ]
+    },
+    {
+        // A rider's gear is what they wear (AGL-4065): "Riding Gear Item" took a
+        // gear wheel of a transmission, tagged "gear, mechanics, bikes".
+        objects: [
+            'gear'
+        ],
+        within: [
+            'motocross',
+            'motorcycle',
+            'motorbike',
+            'dirtbike',
+            'dirt bike',
+            'enduro',
+            'atv'
+        ],
+        kin: [
+            'riding gear',
+            'motocross gear',
+            'protective gear',
+            'helmet',
+            'helmets',
+            'motocross helmet',
+            'motorcycle helmet',
+            'jersey',
+            'boots',
+            'goggles',
+            'gloves'
+        ],
+        queries: [
+            'motocross gear',
+            'motocross helmet'
+        ]
+    },
+    {
+        // A dirt bike's tire is knobby; a car's on a highway is not one (AGL-4065).
+        objects: [
+            'tire'
+        ],
+        within: [
+            'motocross',
+            'motorcycle',
+            'motorbike',
+            'dirtbike',
+            'dirt bike',
+            'enduro',
+            'atv'
+        ],
+        kin: [
+            'tire',
+            'tires',
+            'knobby tire',
+            'motocross tire',
+            'dirt bike tire',
+            'motorcycle tire',
+            'bike tire',
+            'wheel'
+        ],
+        queries: [
+            'dirt bike tire',
+            'motocross tire'
+        ]
+    },
+    {
+        // A brake pad is a brake's (AGL-4092): "Brake Pad Set" found nothing by its
+        // pad, then searched "part" alone and took a transmission chain.
+        objects: [
+            'brake',
+            'pad',
+            'rotor',
+            'caliper'
+        ],
+        within: [
+            'motocross',
+            'motorcycle',
+            'motorbike',
+            'dirtbike',
+            'dirt bike',
+            'enduro',
+            'atv'
+        ],
+        kin: [
+            'brake',
+            'brakes',
+            'brake pad',
+            'brake pads',
+            'brake disc',
+            'brake caliper',
+            'disc brake',
+            'brake rotor'
+        ],
+        queries: [
+            'motorcycle brake disc',
+            'dirt bike brake'
+        ]
+    },
+    {
+        // An engine's air is its filter's (AGL-4092): "Engine and air" tiled a
+        // collection with a bare foot tagged "body part".
+        objects: [
+            'engine',
+            'filter',
+            'air',
+            'carburetor'
+        ],
+        within: [
+            'motocross',
+            'motorcycle',
+            'motorbike',
+            'dirtbike',
+            'dirt bike',
+            'enduro',
+            'atv'
+        ],
+        kin: [
+            'engine',
+            'air filter',
+            'motorcycle engine',
+            'dirt bike engine',
+            'carburetor'
+        ],
+        queries: [
+            'dirt bike engine',
+            'motorcycle engine'
+        ]
+    },
+    {
+        // A taco trailer is a food truck, never a tank truck at a rest stop (AGL-4092).
+        objects: [
+            'trailer',
+            'truck'
+        ],
+        within: [
+            'taco',
+            'taqueria',
+            'burrito',
+            'mexican food',
+            'street food',
+            'food truck'
+        ],
+        kin: [
+            'food truck',
+            'food trailer',
+            'taco truck',
+            'taco trailer',
+            'street food truck'
+        ],
+        queries: [
+            'taco truck',
+            'food truck'
+        ]
+    },
+    {
+        // A taco trailer's chips are tortilla chips, never crisps or a cookie's (AGL-4092).
+        objects: [
+            'chip'
+        ],
+        within: [
+            'taco',
+            'taqueria',
+            'burrito',
+            'mexican food',
+            'street food',
+            'food truck'
+        ],
+        kin: [
+            'tortilla chip',
+            'tortilla chips',
+            'chips and salsa',
+            'chips salsa',
+            'nachos',
+            'nacho'
+        ],
+        queries: [
+            'tortilla chips salsa',
+            'nachos'
+        ]
+    },
+    {
+        // A fountain drink is a soda, never a well's fountain (AGL-4092).
+        objects: [
+            'drink',
+            'soda'
+        ],
+        within: [
+            'taco',
+            'taqueria',
+            'burrito',
+            'mexican food',
+            'street food',
+            'food truck'
+        ],
+        // Never "fountain drink" itself: a well's page address says it word for word.
+        kin: [
+            'soda',
+            'soft drink',
+            'iced tea',
+            'agua fresca',
+            'lemonade',
+            'soda cup'
+        ],
+        queries: [
+            'soda cup',
+            'agua fresca'
+        ]
     }
 ];
 /** 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;
+    return (_OBJECT_KIN_find = OBJECT_KIN.find((entry)=>entry.objects.some((word)=>aiStockStem(word) === object) && entry.within.some((word)=>world.includes(stemPhrase(word))))) != null ? _OBJECT_KIN_find : null;
 }
 /**
  * The kin of a few common crafts: the words a photo of that world is
@@ -1389,6 +1857,388 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
                 'analog'
             ]
         }
+    },
+    // The six trades of the 2026-10-25 booth kit (AGL-4065), none of which the
+    // table listed: a landscaper and a handyman widened to an office, three
+    // motocross businesses took race cars, cyclists, horses and scooters, and a
+    // taco trailer that also takes catering requests was read as a caterer.
+    {
+        // A landscaper's photos are lawns, beds and gardens at work; a zen garden
+        // of raked sand is not one (Bluebonnet's irrigation section).
+        match: [
+            'landscaping',
+            'landscaper',
+            'landscapers',
+            'lawn',
+            'lawns',
+            'xeriscape',
+            'xeriscaping',
+            'sod',
+            'irrigation',
+            'hardscape',
+            'hardscaping',
+            'gardening',
+            'gardener',
+            'gardeners'
+        ],
+        kin: [
+            'landscaping',
+            'landscape',
+            'landscaper',
+            'lawn',
+            'grass',
+            'garden',
+            'yard',
+            'mower',
+            'mowing',
+            'lawn mower',
+            'turf',
+            'hedge',
+            'shrub',
+            'mulch',
+            'sprinkler',
+            'planting',
+            'flowerbed',
+            'flower bed',
+            'backyard',
+            'gardening',
+            'gardener',
+            'xeriscape',
+            'sod',
+            'irrigation'
+        ],
+        broad: [
+            'lawn care',
+            'landscaping garden',
+            'garden landscaping'
+        ],
+        making: [
+            'landscaper mowing lawn',
+            'gardener planting'
+        ],
+        shunLead: [
+            'zen',
+            'sand',
+            'office',
+            'business',
+            'desk',
+            'laptop',
+            'meeting',
+            'golf',
+            'stadium'
+        ]
+    },
+    {
+        // A handyman's photos are tools and repairs; never an architect's house
+        // with a family before it, nor a job application (Two Oaks).
+        match: [
+            'handyman',
+            'handymen',
+            'repairman',
+            'drywall',
+            'remodel',
+            'remodeling',
+            'remodeler',
+            'renovation',
+            'renovations',
+            'home repair'
+        ],
+        kin: [
+            'handyman',
+            'tools',
+            'tool',
+            'tool belt',
+            'toolbox',
+            'drill',
+            'hammer',
+            'screwdriver',
+            'wrench',
+            'ladder',
+            'workshop',
+            'repair',
+            'home repair',
+            'carpenter',
+            'carpentry',
+            'renovation',
+            'remodel',
+            'deck',
+            'fence',
+            'door',
+            'wall',
+            'plaster',
+            'drywall',
+            'construction'
+        ],
+        broad: [
+            'handyman tools',
+            'home repair',
+            'carpenter workshop'
+        ],
+        making: [
+            'handyman at work',
+            'handyman drilling'
+        ],
+        shunLead: [
+            'architecture',
+            'family',
+            'office',
+            'application',
+            'job',
+            'business',
+            'meeting',
+            'desk',
+            'laptop'
+        ]
+    },
+    {
+        // Motocross and the motorcycle world: a dirt bike, never a bicycle, a
+        // race car, a horse or a scooter (Rut Runners, Holeshot, Berm & Bolt).
+        match: [
+            'motocross',
+            'motorcycle',
+            'motorcycles',
+            'motorbike',
+            'motorbikes',
+            'dirtbike',
+            'dirtbikes',
+            'dirt bike',
+            'enduro',
+            'supercross',
+            'moto',
+            'mx',
+            'atv',
+            'quad bike',
+            'powersports'
+        ],
+        kin: [
+            'motocross',
+            'dirt bike',
+            'dirtbike',
+            'enduro',
+            'supercross',
+            'motorbike',
+            'motorcycle',
+            'mx',
+            'atv',
+            'quad bike',
+            'motocross track',
+            'motocross rider',
+            'dirt track'
+        ],
+        near: [
+            'rider',
+            'riders',
+            'helmet',
+            'jump',
+            'track',
+            'mud',
+            'dust',
+            'berm',
+            'racing',
+            'race',
+            'racer'
+        ],
+        broad: [
+            'motocross',
+            'dirt bike',
+            'motocross race',
+            'motocross rider'
+        ],
+        making: [
+            'motorcycle mechanic',
+            'motorcycle workshop'
+        ],
+        rivals: {
+            words: [
+                'bicycle',
+                'bicycles',
+                'cycling',
+                'cyclist',
+                'cyclists',
+                'cycle racing',
+                'bike race',
+                'road bike',
+                'mountain bike',
+                'mtb',
+                'downhill',
+                'car',
+                'cars',
+                'race car',
+                'formula',
+                'kart',
+                'karting',
+                'horse',
+                'horses',
+                'equestrian',
+                'scooter',
+                'moped',
+                'vespa',
+                'cruiser',
+                'chopper'
+            ],
+            core: [
+                'motocross',
+                'motorcycle',
+                'motorbike',
+                'dirt bike',
+                'dirtbike',
+                'supercross',
+                'atv',
+                'quad bike'
+            ]
+        },
+        shunLead: [
+            'car',
+            'scooter',
+            'moped',
+            'cruiser',
+            'chopper',
+            'vespa',
+            'bicycle',
+            'cyclist',
+            'horse',
+            'highway',
+            'asphalt',
+            'traffic'
+        ],
+        // A motocross team's "Gate drop" took a man posing with a street bike, tagged "man, model, motorcycle" (AGL-4092).
+        wider: {
+            words: [
+                'motorcycle',
+                'motorcycles',
+                'motorbike',
+                'motorbikes',
+                'moto'
+            ],
+            shunLead: [
+                'model',
+                'urban',
+                'street',
+                'road bike',
+                'road racing',
+                'sportbike',
+                'superbike',
+                'studio',
+                'posing'
+            ]
+        }
+    },
+    {
+        // A parts shop of the motocross world: its parts, tires and riding gear,
+        // never a canoe, a delivery or an industrial lathe (Berm & Bolt).
+        match: [
+            'parts',
+            'part',
+            'aftermarket',
+            'oem',
+            'spare parts'
+        ],
+        of: [
+            'motocross',
+            'motorcycle',
+            'motorbike',
+            'dirtbike',
+            'dirt bike',
+            'enduro',
+            'supercross',
+            'moto',
+            'atv',
+            'quad bike',
+            'powersports'
+        ],
+        kin: [
+            'parts',
+            'part',
+            'spare part',
+            'motorcycle parts',
+            'tire',
+            'tires',
+            'wheel',
+            'chain',
+            'sprocket',
+            'brake',
+            'exhaust',
+            'riding gear',
+            'helmet'
+        ],
+        broad: [
+            'dirt bike parts',
+            'motorcycle parts',
+            'motocross gear'
+        ],
+        making: [
+            'motorcycle mechanic',
+            'motorcycle workshop'
+        ],
+        shunLead: [
+            'canoe',
+            'river',
+            'delivery',
+            'food',
+            'trees',
+            'office',
+            'industry',
+            'industrial',
+            'factory'
+        ]
+    },
+    {
+        // A taco trailer's photos are tacos and the truck, never a hotel's buffet,
+        // a chef in whites or raw potatoes (Pit Row Tacos).
+        match: [
+            'taco',
+            'tacos',
+            'taqueria',
+            'taco truck',
+            'taco trailer',
+            'burrito',
+            'burritos'
+        ],
+        kin: [
+            'taco',
+            'tacos',
+            'tortilla',
+            'tortillas',
+            'salsa',
+            'mexican',
+            'mexican food',
+            'street food',
+            'food truck',
+            'taco truck',
+            'griddle',
+            'burrito',
+            'quesadilla',
+            'nachos',
+            'guacamole',
+            'carnitas',
+            'pastor',
+            'asada'
+        ],
+        broad: [
+            'tacos',
+            'street tacos',
+            'taco truck'
+        ],
+        making: [
+            'taco truck cooking',
+            'tacos on the griddle'
+        ],
+        out: [
+            'food truck crowd',
+            'street food customers',
+            'taco stand customers'
+        ],
+        shunLead: [
+            'buffet',
+            'hotel',
+            'fine dining',
+            'chef',
+            'indian',
+            'potato',
+            'banquet',
+            'cafeteria',
+            'wedding'
+        ]
     }
 ];
 /** Lowercase words, letters only, without stopwords. */ function contentWords(text) {
@@ -1409,28 +2259,60 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
     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) {
+/** 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));
+/**
+ * A business type's clauses, each with the word that opened it. Where the
+ * business's own clause is a word or two joined by "and" to a noun phrase
+ * that ends in a place of business ("Motorcycle and dirt bike repair shop",
+ * "Dirt bike and ATV parts shop"), the two are one clause (AGL-4065): the
+ * Holeshot start read its business as "motorcycle" and lost the dirt bikes,
+ * Berm & Bolt's as "dirt bike" and its craft as "bike". "And" before a verb
+ * or a place still ends the clause. A clause that opens with what a customer
+ * may ask ("takes", "books") loses that verb.
+ */ function businessClauses(businessType) {
     const text = businessType.toLowerCase().replace(DOING, ' | ');
     const clauses = [];
     const breaker = new RegExp(`${BUSINESS_BREAK.source}|\\|`, 'g');
     let at = 0;
     let opener = '';
+    const push = (raw)=>{
+        var _found_;
+        const found = contentWords(raw);
+        // Never the type's first words: "Books and coffee" sells books.
+        const asked = opener !== '' && found.length > 1 && TRANSACTION_VERBS.has((_found_ = found[0]) != null ? _found_ : '');
+        clauses.push(_extends({
+            opener,
+            words: asked ? found.slice(1) : found
+        }, asked ? {
+            asked: true
+        } : {}));
+    };
     for (const match of text.matchAll(breaker)){
         var _match_index;
-        clauses.push({
-            opener,
-            words: contentWords(text.slice(at, match.index))
-        });
+        push(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))
-    });
+    push(text.slice(at));
+    const own = clauses.findIndex((clause)=>businessOf(clause.words).length > 0);
+    const first = clauses[own];
+    const next = clauses[own + 1];
+    if (first && next && (next.opener === 'and' || next.opener === '&')) {
+        var _right_;
+        const left = businessOf(first.words);
+        const right = businessOf(next.words);
+        const head = (_right_ = right[right.length - 1]) != null ? _right_ : '';
+        if (left.length <= 2 && left.every((word)=>!VENUES.has(word) && !ROLES.has(word)) && right.length >= 2 && VENUES.has(head)) clauses.splice(own, 2, {
+            opener: first.opener,
+            words: [
+                ...first.words,
+                ...next.words
+            ],
+            joined: next.words
+        });
+    }
     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 that says more than what kind of site it is, before a place, an
@@ -1438,9 +2320,13 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
  * 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".
+ * A business named by two things joined by "and" is its second noun phrase
+ * whole: "dirt bike repair shop" of "Motorcycle and dirt bike repair shop"
+ * (AGL-4065).
  */ export function aiStockBusinessWords(businessType) {
-    for (const { words: clause } of businessClauses(businessType)){
+    for (const { words: clause, joined } of businessClauses(businessType)){
         const named = businessOf(clause);
+        if (joined) return businessOf(joined).slice(-4).join(' ');
         if (named.length) return named.slice(-3).join(' ');
     }
     return '';
@@ -1455,16 +2341,36 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
     const craft = named[named.length - 1];
     return craft ? aiStockStem(craft) : '';
 }
-/** The site's terms, read from its business type. */ export function aiStockSiteTerms(businessType) {
+/** A word or phrase of a group's list, as stems: what a business type and a hit are read for. */ const groupTerm = (word)=>stemPhrase(word);
+/**
+ * The site's terms, read from its business type.
+ *
+ * Two worlds are read (AGL-4065). Its DOMAIN is everything its words name
+ * of its world, what a picture of a thing is held to. Its LEAD is the
+ * business's own world: the listed crafts its own clause names (and the
+ * craft's), their names and kin, and the clause's own words where no craft
+ * covers them, never a word that names a world only beside another ("race",
+ * "team") nor what a customer is asked to do. A hero's first tag and a broad
+ * search's hit name the lead: the Rut Runners heroes, held to every word of
+ * "Amateur motocross race team: rider profiles, race schedule…", took race
+ * cars because "race car" named "race". Of the crafts its words list, the one
+ * named first leads (a taco trailer that "takes catering requests" is a taco
+ * trailer), and a craft named only in what a customer may ask for gives the
+ * site no searches of its own.
+ */ export function aiStockSiteTerms(businessType) {
     let business = aiStockBusinessWords(businessType);
     let craft = aiStockCraftWords(business);
     const domain = new Set();
     /** The things it makes, by their head nouns. */ const made = new Set();
+    /** Stems and stem pairs of every clause that names its world, and of those that only say what it is asked for. */ const said = new Set();
+    const asked = new Set();
+    /** The business's own clause, as stems and stem pairs: what its lead is read from. */ let own = [];
+    let ownSeen = false;
     /** 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;
     let place = false;
-    for (const { opener, words: clause } of businessClauses(businessType)){
+    for (const { opener, words: clause, asked: isAsked } 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)) {
@@ -1478,6 +2384,10 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         if (place && opener === ',') continue;
         place = false;
         const kept = businessOf(clause).filter((word)=>!VENUES.has(word) && !ROLES.has(word));
+        if (!ownSeen && businessOf(clause).length) {
+            ownSeen = true;
+            own = kept.filter((word)=>!LEAD_GENERIC.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".
@@ -1485,32 +2395,55 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         // A set or a gift is never a world: "gift" of "gift sets" is not one.
         const world = (making ? kept.slice(0, -1) : kept).filter((word)=>!WRAPPERS.has(word));
         for (const word of world)for (const stem of stemList(word))domain.add(stem);
+        for (const term of termsOf([
+            kept.join(' ')
+        ]))(isAsked ? asked : said).add(term);
         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);
     }
     // 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));
+    const typeStems = stemList(businessType);
+    const typeTerms = withPairs(typeStems);
+    /** Where a word or a two-word name first stands in the business type; the end where it stands nowhere. */ const positionOf = (term)=>{
+        const [head, tail] = term.split(' ');
+        const index = typeStems.findIndex((stem, at)=>stem === head && (tail === undefined || typeStems[at + 1] === tail));
+        return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+    };
+    /** Where a group's list first meets the business type, its words in order. */ const at = (list)=>Math.min(...list.map((word)=>positionOf(groupTerm(word))));
+    const names = (word)=>{
+        const term = groupTerm(word);
+        return term.includes(' ') ? said.has(term) || asked.has(term) : domain.has(term) || made.has(term) || term === craft;
+    };
+    const found = CRAFT_KIN.map((group, index)=>({
+            group,
+            index
+        })).filter(({ group })=>group.match.some(names) && (!group.of || group.of.some(names))).sort((a, b)=>Number(Boolean(b.group.of)) - Number(Boolean(a.group.of)) || at(a.group.match) - at(b.group.match) || a.index - b.index);
+    const groups = found.map(({ group })=>group);
+    // A craft named only in what the business is asked for ("takes catering
+    // requests") lends its kin and its refusals, never its searches (AGL-4065).
+    const major = groups.filter((group)=>group.match.some((word)=>said.has(groupTerm(word)) || made.has(groupTerm(word))));
     // 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));
+        var _major_;
+        const listed = (_major_ = major[0]) == null ? void 0 : _major_.match.map(groupTerm).find((stem)=>!stem.includes(' ') && (domain.has(stem) || made.has(stem)));
         craft = listed || firstWorld || [
             ...made
         ][0] || '';
         if (craft && !stemList(business).includes(craft)) business = `${craft} ${business}`.trim();
-    } else if (groups[0] && !groups.some((group)=>group.match.some((word)=>aiStockStem(word) === craft))) {
-        var _groups__match_map_find;
+    } else if (major[0] && !major.some((group)=>group.match.some((word)=>groupTerm(word) === craft))) {
+        var _major__match_map_find;
         // A word the table does not list, beside a craft it does, says what kind
         // of that craft it is (AGL-3856): "wedding" of "a wedding and portrait
         // photographer" is a photographer's subject, never a craft to search by.
-        craft = (_groups__match_map_find = groups[0].match.map(aiStockStem).find((stem)=>domain.has(stem) || made.has(stem))) != null ? _groups__match_map_find : craft;
+        craft = (_major__match_map_find = major[0].match.map(groupTerm).find((stem)=>!stem.includes(' ') && (domain.has(stem) || made.has(stem)))) != null ? _major__match_map_find : craft;
     }
     if (craft) domain.add(craft);
+    const craftGroup = major.find((group)=>group.match.some((word)=>groupTerm(word) === craft));
     const broad = [];
     const makingSearches = [];
     const rivals = [];
@@ -1520,25 +2453,96 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
     const shun = new Set();
     const shunLead = new Set();
     for (const group of groups){
-        var _group_shun, _group_shunLead;
-        for (const word of (_group_shun = group.shun) != null ? _group_shun : [])shun.add(aiStockStem(word));
-        for (const word of (_group_shunLead = group.shunLead) != null ? _group_shunLead : [])shunLead.add(aiStockStem(word));
-        for (const word of group.match)core.add(aiStockStem(word));
-        for (const word of group.kin)domain.add(aiStockStem(word));
-        broad.push(...group.broad);
-        makingSearches.push(...group.making);
+        var _group_shun, _group_shunLead, _group_near;
+        for (const word of (_group_shun = group.shun) != null ? _group_shun : [])shun.add(groupTerm(word));
+        for (const word of (_group_shunLead = group.shunLead) != null ? _group_shunLead : [])shunLead.add(groupTerm(word));
+        for (const word of [
+            ...group.kin,
+            ...(_group_near = group.near) != null ? _group_near : []
+        ])domain.add(groupTerm(word));
         if (group.rivals) rivals.push({
-            words: group.rivals.words.map(aiStockStem),
-            core: group.rivals.core.map(aiStockStem)
+            words: group.rivals.words.map(groupTerm),
+            core: group.rivals.core.map(groupTerm)
         });
     }
+    for (const group of major){
+        for (const word of group.match)core.add(groupTerm(word));
+        broad.push(...group.broad);
+        makingSearches.push(...group.making);
+    }
+    // A two-word name of a listed world names it whole: "dirt bike", never
+    // "bike" (a bicycle's) where the type says it nowhere else (AGL-4065).
+    for (const group of groups)for (const word of group.match){
+        const term = groupTerm(word);
+        if (!term.includes(' ') || !typeTerms.includes(term)) continue;
+        domain.add(term);
+        const [head, tail] = term.split(' ');
+        const alone = (stem)=>typeStems.some((found, index)=>found === stem && !(found === head ? typeStems[index + 1] === tail : typeStems[index - 1] === head));
+        for (const stem of [
+            head,
+            tail
+        ])if (!alone(stem)) domain.delete(stem);
+    }
+    // What a customer is asked to do is never a world (AGL-4065).
+    for (const stem of TRANSACTION_STEMS)domain.delete(stem);
+    // The business's own world: the crafts its own clause names, and the craft's.
+    const ownTerms = new Set(termsOf([
+        own.join(' ')
+    ]));
+    const leading = major.filter((group)=>group === craftGroup || group.match.some((word)=>ownTerms.has(groupTerm(word))));
+    const lead = new Set();
+    for (const group of leading)for (const word of [
+        ...group.match,
+        ...group.kin
+    ])lead.add(groupTerm(word));
+    if (leading.length) {
+        for (const word of own)for (const stem of stemList(word))if (![
+            ...lead
+        ].some((term)=>term === stem || term.includes(' ') && term.split(' ').includes(stem) && ownTerms.has(term))) lead.add(stem);
+    }
+    // A wider world's names lead only where the business's own words say them
+    // (AGL-4092): a motocross team's world is off-road, never "motorcycle" alone.
+    for (const group of leading){
+        if (!group.wider) continue;
+        const wider = group.wider.words.map(groupTerm);
+        if (wider.some((term)=>ownTerms.has(term))) continue;
+        for (const term of wider)lead.delete(term);
+        for (const word of group.wider.shunLead)shunLead.add(groupTerm(word));
+    }
+    // A trade's world, named by the world it serves: "dirt bike" for a dirt bike parts shop.
+    const served = (craftGroup == null ? void 0 : craftGroup.of) ? groups.filter((group)=>group !== craftGroup).flatMap((group)=>group.match).filter((word)=>typeTerms.includes(groupTerm(word))).sort((a, b)=>positionOf(groupTerm(a)) - positionOf(groupTerm(b)))[0] : undefined;
     if (!broad.length) broad.push(business, craft);
+    // A part or gear names no world on its own: a dirt bike shop's part, never a canoe's (AGL-4065).
+    const ofAWorld = (term)=>term.length > 1 && !term.split(' ').every((word)=>WORLD_OBJECTS.has(word));
+    // A trade's things are held to the world it serves, never to its own word (AGL-4092).
+    const tradeNames = new Set(((craftGroup == null ? void 0 : craftGroup.of) ? craftGroup.match : []).map(groupTerm));
+    const held = (craftGroup == null ? void 0 : craftGroup.of) ? [
+        ...core
+    ].filter((term)=>ofAWorld(term) && !tradeNames.has(term)) : [];
+    const out = [
+        ...new Set(leading.flatMap((group)=>{
+            var _group_out;
+            return (_group_out = group.out) != null ? _group_out : [];
+        }))
+    ];
     return _extends({
         business,
         craft,
         domain: [
             ...domain
         ].filter((stem)=>stem.length > 1),
+        lead: leading.length ? [
+            ...lead
+        ].filter(ofAWorld) : [
+            ...domain
+        ].filter((stem)=>stem.length > 1)
+    }, served ? {
+        leadWord: served
+    } : {}, held.length ? {
+        held
+    } : {}, out.length ? {
+        out
+    } : {}, {
         broad: [
             ...new Set(broad.map((query)=>query.trim()).filter(Boolean))
         ],
@@ -1559,12 +2563,12 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         ]
     } : {}, {
         named: [
-            ...new Set(stemList(businessType))
+            ...new Set(typeTerms)
         ],
         rivals,
         core: [
             ...core
-        ],
+        ].filter((term)=>!(craftGroup == null ? void 0 : craftGroup.of) || ofAWorld(term)),
         shun: [
             ...shun
         ],
@@ -1578,20 +2582,45 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
  * the beta.266 Mexicano portfolio's gallery was "Project one" to "Project
  * four", and searched "project" (students at a whiteboard), "project four"
  * (lavender) and "four" (a running track's lane numbers).
- */ const PLACEHOLDER_SUBJECTS = words('project projects piece pieces item items example examples sample samples entry entries untitled work works ' + 'selected recent latest ' + 'four five six seven eight nine ten first second third fourth fifth sixth seventh eighth ninth tenth');
+ */ const PLACEHOLDER_SUBJECTS = words('project projects piece pieces item items example examples sample samples entry entries untitled work works ' + 'selected recent latest ' + 'four five six seven eight nine ten first second third fourth fifth sixth seventh eighth ninth tenth ' + // When a thing is, never the thing (AGL-4065): "Upcoming race 1 (details to be added)" searched "upcoming race".
+'upcoming past next previous future');
 /** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(list) {
-    return list.filter((word)=>!FILLER.has(word) && !PLACEHOLDER_SUBJECTS.has(word));
+    return list.filter((word)=>!FILLER.has(word) && !PLACEHOLDER_SUBJECTS.has(word) && !GENERIC_OBJECTS.has(word) && !SENTENCE_WORDS.has(word));
 }
 /**
  * A picture's subject in a few words (AGL-3660): the noun phrase its alt
  * text opens with — its first clause holding more than filler, cut where a
  * preposition starts the setting, filler dropped, its last three words (the
- * head noun is the last) — else its section's name.
+ * head noun is the last) — else its section's name. A word or two joined by
+ * "and" to a longer noun phrase only modify its head: the subject of "Potato
+ * and egg breakfast taco" is "egg breakfast taco", never "potato" (AGL-4065).
  */ export function aiStockSubjectWords(alt, sectionName) {
     // "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(' ');
+    const text = withoutHands(alt);
+    const breaker = new RegExp(CLAUSE_BREAK.source, 'g');
+    const clauses = [];
+    let at = 0;
+    for (const match of text.matchAll(breaker)){
+        var _match_index;
+        clauses.push({
+            words: subjectOf(contentWords(text.slice(at, match.index))),
+            then: match[0].trim()
+        });
+        at = ((_match_index = match.index) != null ? _match_index : 0) + match[0].length;
+    }
+    clauses.push({
+        words: subjectOf(contentWords(text.slice(at))),
+        then: ''
+    });
+    for (const [index, { words: found, then }] of clauses.entries()){
+        var _ref;
+        var _clauses_;
+        if (!found.length) continue;
+        // Never where the second is one thing in a wrapper: "Soap and Lotion Gift Set" is a gift of both.
+        const next = (_ref = (_clauses_ = clauses[index + 1]) == null ? void 0 : _clauses_.words) != null ? _ref : [];
+        const things = next.filter((word)=>!WRAPPERS.has(word));
+        if ((then === 'and' || then === '&') && found.length <= 2 && things.length >= 2) return next.slice(-3).join(' ');
+        return found.slice(-3).join(' ');
     }
     return subjectOf(contentWords(withoutHands(sectionName))).slice(0, 2).join(' ');
 }
@@ -1599,10 +2628,12 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
  * 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").
+ * is one ("gift set"). A feeling, a time or a way of being somewhere is
+ * never one ({@link NON_THINGS}, AGL-4092): "Come hungry" and "Around town"
+ * show no thing, and "Race day" is of the race.
  */ export function aiStockObjectWord(subject) {
     var _ref, _reverse_find;
-    const list = subject.split(/\s+/).filter(Boolean);
+    const list = subject.split(/\s+/).filter((word)=>word && !NON_THINGS.has(word));
     const object = (_ref = (_reverse_find = [
         ...list
     ].reverse().find((word)=>!WRAPPERS.has(word))) != null ? _reverse_find : list[list.length - 1]) != null ? _ref : '';
@@ -2378,7 +3409,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * product names it. A size never names the product: "Bath Gift Set Starter
  * Size" is a bath gift set.
  */ export function aiStockProductSearches(slot, craft, domain = [], fallback = {}) {
-    var _ref, _subjects_, _fallback_core, _ref1, _fallback_broad, _fallback_broad1;
+    var _ref, _subjects_, _fallback_held, _fallback_core, _fallback_leadWord, _ref1, _fallback_broad, _fallback_broad1;
     var _slot_product;
     const orientation = aiStockOrientation(slot.aspect);
     const size = orientation === 'vertical' ? {
@@ -2404,23 +3435,31 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     // 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 ? [
+    // A trade's product is held to the world it serves, never to its craft
+    // (AGL-4092): a parts shop's "part" named a transmission's "mechanical part".
+    const served = [
+        ...new Set(((_fallback_held = fallback.held) != null ? _fallback_held : []).map(stemPhrase).filter(Boolean))
+    ];
+    const trade = served.length > 0;
+    const category = trade ? served : craft && ownWorld.length ? [
         ...craftStems,
         ...ownWorld
     ] : [];
-    const core = [
+    const core = trade ? served : [
         ...new Set([
             ...craftStems,
             ...(_fallback_core = fallback.core) != null ? _fallback_core : []
         ])
     ];
+    // A trade's product is named by the world it serves: "dirt bike skid plate", never "part skid plate".
+    const prefix = trade ? (_fallback_leadWord = fallback.leadWord) != null ? _fallback_leadWord : '' : craft;
     const shun = ((_ref1 = kin == null ? void 0 : kin.shun) != null ? _ref1 : []).map(aiStockStem);
     const queries = [];
     for (const subject of subjects){
         var _ref2;
         const stems = stemList(subject);
         const qualifier = (_ref2 = kin == null ? void 0 : kin.qualifier) != null ? _ref2 : '';
-        const query = kin ? !qualifier || stems.includes(aiStockStem(qualifier)) ? subject : kin.after ? `${subject} ${qualifier}` : `${qualifier} ${subject}` : craft && !stems.some((stem)=>world.has(stem)) ? `${craft} ${subject}` : subject;
+        const query = kin ? !qualifier || stems.includes(aiStockStem(qualifier)) ? subject : kin.after ? `${subject} ${qualifier}` : `${qualifier} ${subject}` : prefix && !stems.some((stem)=>world.has(stem)) ? `${prefix} ${subject}` : subject;
         queries.push({
             query,
             subject,
@@ -2444,7 +3483,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         object,
         lead: true
     });
-    else if (craft) queries.push({
+    else if (craft && !trade) queries.push({
         query: craft,
         subject: own || craft,
         object: craft,
@@ -2507,6 +3546,8 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             tier: entry.tier
         } : {}, shun.length ? {
             shun
+        } : {}, trade ? {
+            served
         } : {});
         if (entry.broad) {
             const heldTo = [
@@ -2523,9 +3564,11 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
                 kin: kinPhrases
             } : {}, heldTo.length ? {
                 category: heldTo
-            } : {}) : core.length ? {
+            } : {}) : core.length ? _extends({
                 category: core
-            } : {}));
+            }, trade ? {
+                leadOwn: true
+            } : {}) : {}));
             continue;
         }
         searches.push(_extends({}, common, entry.lead ? {
@@ -2536,7 +3579,9 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             object: entry.object
         } : {}, kinPhrases.length && entry.object === object ? {
             kin: kinPhrases
-        } : {}, craft ? {
+        } : {}, trade ? {
+            strict: true
+        } : craft ? {
             requires: craft
         } : {}, category.length ? {
             category
@@ -2550,8 +3595,8 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * asks first for the role its words or its list's name (`sectionName`) say,
  * in the site's world: "teacher classroom" for a "Math instructor" (AGL-3856).
  */ export function aiStockSearchesFor(slot, terms, subject, part, sectionName = '') {
-    var _terms_core, _terms_making, _ref, _ref1, _terms_setting, _terms_setting1, _ref2, _terms_maker, _terms_maker1, _ref3;
-    var _aiStockPeopleRole, _slot_record, _slot_record1;
+    var _terms_core, _terms_leadWord, _terms_making, _ref, _ref1, _terms_setting, _terms_setting1, _ref2, _terms_maker, _terms_maker1, _ref3;
+    var _terms_held, _aiStockPeopleRole, _slot_record, _terms_out, _slot_record1;
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
         minWidth: 1600
@@ -2596,16 +3641,36 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     // 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;
+    // The world a trade serves qualifies its pictures where the craft is the trade: "dirt bike", never "part" (AGL-4065).
+    const leadWord = (_terms_leadWord = terms.leadWord) != null ? _terms_leadWord : terms.craft;
+    const leadStems = stemList(leadWord);
+    const qualify = (phrase)=>leadWord && !namesWorld && !leadStems.every((stem)=>stemList(phrase).includes(stem)) ? `${leadWord} ${phrase}` : phrase;
+    // A part, gear, a machine, or one word of a two-word world ("bike" of "dirt
+    // bike"), is never searched alone (AGL-4065): searched with the world, and
+    // its photo is OF the thing and names the world. "Parts for the ranch"
+    // searched "parts" and took a canoe tagged "part".
+    const ofTheWorld = Boolean(leadWord) && subjectStems.length > 0 && subjectStems.every((stem)=>WORLD_OBJECTS.has(stem) || leadStems.includes(stem)) && (subjectStems.some((stem)=>WORLD_OBJECTS.has(stem)) || leadStems.length > 1 && subjectStems.length < leadStems.length);
+    /** The words a photo of the world names, the world's things left out: a dirt bike's, never "part". */ const worldNames = core.filter((stem)=>!stem.split(' ').some((word)=>WORLD_OBJECTS.has(word)));
     // 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) && !work;
-    const broad = kin && collection || work ? [] : terms.broad.filter(shown).map((query)=>({
+    // A picture's broad searches find a photo OF the business's own world,
+    // never one naming it in a word of a tag (AGL-4092); a hero's first tag
+    // already names it.
+    const broad = kin && collection || work ? [] : terms.broad.filter(shown).map((query)=>_extends({
             query,
             broad: true,
             category: collection
+        }, slot.role === 'hero' ? {} : {
+            own: true
         }));
+    // A trade's things are held to the world it serves, never to its craft (AGL-4092).
+    const heldTo = ((_terms_held = terms.held) == null ? void 0 : _terms_held.length) ? terms.held : null;
+    // A caption that names no thing (AGL-4092): "Come hungry" is a picture of
+    // the site's own world, and "Around town" of its customers out where it is.
+    const thingless = Boolean(subject) && !object && !work;
+    const out = thingless && slot.role !== 'hero' && PLACE_PHRASES.test(slot.alt);
     // The maker at work, held to the craft: never "hands" (AGL-3660).
     const makers = (work ? [] : (_terms_making = terms.making) != null ? _terms_making : []).filter(shown).map((query)=>({
             query,
@@ -2627,21 +3692,61 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     }
     // The work's own subject is never qualified by the craft: "getting ready", never "photographer getting ready".
     const own = work ? (phrase)=>phrase : qualify;
-    const thing = (subject ? [
+    // A record's cover is OF what it names, searched in the site's world first
+    // (AGL-4065): "handyman drywall" before "drywall", which took an architect's
+    // house with a family before its studs.
+    const record = Boolean(slot.record) && !work && !ofTheWorld && Boolean(leadWord);
+    const thing = (!subject ? [] : thingless ? out ? (((_terms_out = terms.out) == null ? void 0 : _terms_out.length) ? terms.out : [
+        `${leadWord} customers`.trim()
+    ]).map((query)=>({
+            query,
+            out: true
+        })) : [
         {
-            query: own(subject),
-            held: true
+            query: `${leadWord} ${subject}`.trim(),
+            own: true
+        }
+    ] : ofTheWorld ? [
+        {
+            query: `${leadWord} ${subjectStems.some((stem)=>!leadStems.includes(stem)) ? subject.split(/\s+/).filter((word)=>!leadStems.includes(aiStockStem(word))).join(' ') : ''}`.trim(),
+            held: true,
+            leads: true,
+            ofWorld: true
         },
         ...kin ? kin.queries.map((query)=>({
                 query,
-                held: true
-            })) : [
+                held: true,
+                leads: true,
+                ofWorld: true
+            })) : []
+    ] : [
+        ...record && !leadStems.every((stem)=>subjectStems.includes(stem)) ? [
             {
+                query: `${leadWord} ${subject}`,
+                held: true,
+                leads: true
+            }
+        ] : [],
+        _extends({
+            query: own(subject),
+            held: true
+        }, record ? {
+            leads: true
+        } : {}),
+        ...kin ? kin.queries.map((query)=>_extends({
+                query,
+                held: true
+            }, record ? {
+                leads: true
+            } : {})) : [
+            _extends({
                 query: own(object),
                 held: true
-            }
+            }, record ? {
+                leads: true
+            } : {})
         ]
-    ] : []).filter((query)=>said(query.query));
+    ]).filter((query)=>said(query.query));
     // Never the maker, the camera, an animal or a toy, unless the record names it.
     const recordNamed = work ? new Set(stemList(`${slot.alt} ${(_ref2 = (_slot_record1 = slot.record) == null ? void 0 : _slot_record1.category) != null ? _ref2 : ''}`)) : null;
     const refuseLead = recordNamed ? [
@@ -2795,20 +3900,36 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             broad: true
         } : {}, held && kinPhrases.length ? {
             kin: kinPhrases
-        } : {}, held && collection ? {
+        } : {}, held && collection || raw.leads ? {
             lead: true
-        } : {}, terms.craft && (raw.category || raw.held && collection) ? _extends({
+        } : {}, terms.craft && !raw.ofWorld && (raw.category || raw.held && collection) ? heldTo ? {
+            category: heldTo,
+            served: heldTo
+        } : _extends({
             requires: terms.craft
         }, ownWorld.length ? {
             category: [
                 terms.craft,
                 ...ownWorld
             ]
-        } : {}) : {}, slot.role === 'hero' && core.length ? {
+        } : {}) : {}, raw.ofWorld && worldNames.length ? {
+            category: worldNames
+        } : {}, slot.role === 'hero' && core.length ? {
             category: core
         } : {}, slot.role === 'hero' ? {
             first: true
-        } : {}, refuseLead.length ? {
+        } : {}, raw.own ? {
+            leadOwn: true
+        } : {}, raw.out ? {
+            broad: true,
+            needs: PLACE_NEEDS.map(stemPhrase),
+            refuseLead: [
+                ...new Set([
+                    ...refuseLead,
+                    ...FOREIGN_STREET.map(stemPhrase)
+                ])
+            ]
+        } : refuseLead.length ? {
             refuseLead
         } : {}, work ? {
             worldless: true
@@ -2849,15 +3970,17 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     var _photo_tags, _photo_alt, _photo_alt1, _tags_, _photo_alt2;
     const slug = pageSlug(photo.pageUrl);
     const tags = ((_photo_tags = photo.tags) != null ? _photo_tags : []).map((tag)=>tag.toLowerCase().trim()).filter(Boolean);
-    const lead = new Set(stemList([
+    // Each tag's words and pairs of them, read tag by tag (AGL-4065): "race car"
+    // and "dirt bike" are phrases a world names; the page address is read whole.
+    const lead = termsOf([
         ...tags.slice(0, 3),
         slug
-    ].join(' ')));
-    const all = new Set(stemList([
+    ]);
+    const all = termsOf([
         ...tags,
         (_photo_alt = photo.alt) != null ? _photo_alt : '',
         slug
-    ].join(' ')));
+    ]);
     const phrases = [
         ...tags.map((tag)=>stemList(tag).join(' ')),
         stemList((_photo_alt1 = photo.alt) != null ? _photo_alt1 : '').join(' '),
@@ -2885,12 +4008,61 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     };
 }
 /** Whether a phrase is among a hit's phrases, word for word. */ const among = (phrases, phrase)=>phrases.some((found)=>` ${found} `.includes(` ${phrase} `));
+/**
+ * Whether one of a hit's first three tags is OF a world (AGL-4092): it names
+ * the world, and its last word, or its last two, is a word of the world or of
+ * its domain. "Street tacos" and "dirt bike tire" are; "taco bowl" is a bowl,
+ * "body part" a part. Read from the tags alone: the page address repeats them
+ * run together, and a run of words has no head.
+ */ function leadsWithWorld(tags, world, domain) {
+    return tags.slice(0, 3).some((tag)=>{
+        var _stems_;
+        const stems = stemList(tag);
+        if (!withPairs(stems).some((term)=>world.has(term))) return false;
+        return [
+            (_stems_ = stems[stems.length - 1]) != null ? _stems_ : '',
+            stems.slice(-2).join(' ')
+        ].some((term)=>Boolean(term) && (world.has(term) || domain.has(term)));
+    });
+}
+/**
+ * What a picture of a business's world is never OF unless its words name it
+ * (AGL-4092): an animal or a toy (as a portfolio's record never is,
+ * {@link RECORD_ODD_LEADS}), or a bare body part. Each group is let in whole
+ * by any of its words in `said` — the slot's words, its section's, the
+ * brief's — so a dog groomer's pictures show dogs and cats alike. As stems;
+ * the body's left out where `body` is false (a portrait's face).
+ */ export function aiStockOddLeads(said, options = {}) {
+    const named = new Set(said.flatMap((text)=>stemList(text)));
+    const groups = [
+        'animal animals cat cats kitten kittens dog dogs puppy puppies pet pets bird birds frog frogs duck ducks horse horses ' + 'cow cows rabbit rabbits bunny',
+        'toy toys figurine figurines lego doll dolls teddy puppet miniature',
+        ...options.body === false ? [] : [
+            `${[
+                ...BODY_PARTS
+            ].join(' ')} toe toes barefoot`
+        ]
+    ].map((group)=>[
+            ...new Set(stemList(group))
+        ]);
+    return groups.filter((group)=>!group.some((stem)=>named.has(stem))).flat();
+}
 /**
  * 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);
+    // A maker's name, in its tags or its page address, unless the site names the maker (AGL-4065),
+    // or a word one letter off it: "susuki" is a Suzuki (AGL-4092).
+    const makers = aiStockMakerTerms(photo);
+    if ([
+        ...MAKER_STEMS
+    ].some((maker)=>makers.has(maker) && !site.has(maker))) return true;
+    for (const term of makers){
+        const maker = term.includes(' ') ? null : fuzzyMaker(term);
+        if (maker && !site.has(maker) && !site.has(term)) return true;
+    }
     return SENSITIVE_STEMS.some((topic)=>[
             ...topic.words
         ].some((word)=>found.has(word)) && ![
@@ -2908,13 +4080,15 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * the subject's two-word phrase 3, each of its other words 1, and the
  * site's world 1, plus a quarter when it is among the first tags.
  */ export function aiStockRelevance(photo, judgement) {
-    var _judgement_rivals, _judgement_subject, _judgement_named, _judgement_shun, _judgement_refuse, _judgement_refuseLead, _judgement_needs, _judgement_shunLead, _judgement_leadAny, _judgement_kin, _judgement_requires, _judgement_category, _judgement_object, _judgement_domain, _judgement_roles;
-    var _judgement_roleScene, _judgement_roleRefuse, _judgement_away;
+    var _judgement_rivals, _judgement_subject, _judgement_named, _judgement_shun, _judgement_refuse, _judgement_refuseLead, _judgement_needs, _judgement_shunLead, _judgement_leadAny, _judgement_kin, _judgement_requires, _judgement_category, _judgement_object, _judgement_domain, _photo_tags, _judgement_roles;
+    var _judgement_served, _judgement_roleScene, _judgement_roleRefuse, _judgement_away, _judgement_world, _judgement_oddLeads;
     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;
+    // A trade's thing is of the world it serves, whatever else names it (AGL-4092).
+    if (((_judgement_served = judgement.served) == null ? void 0 : _judgement_served.length) && !judgement.served.some((term)=>hit.all.has(stemPhrase(term)))) return 0;
     const subject = stemList((_judgement_subject = judgement.subject) != null ? _judgement_subject : '');
     // What the slot or the brief names lets a shunned word, a room or a fragrance in.
     const owned = new Set([
@@ -2930,17 +4104,17 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     // A teacher is shown teaching: a classroom, a lecture or students among the
     // first tags, and never a model, a pose or a painting (AGL-3856).
     if (((_judgement_roleScene = judgement.roleScene) == null ? void 0 : _judgement_roleScene.length) || ((_judgement_roleRefuse = judgement.roleRefuse) == null ? void 0 : _judgement_roleRefuse.length)) {
-        var _photo_tags, _photo_tags1, _judgement_roleRefuse1;
+        var _photo_tags1, _photo_tags2, _judgement_roleRefuse1;
         var _judgement_roleScene1;
-        const first = new Set(stemList(((_photo_tags = photo.tags) != null ? _photo_tags : []).slice(0, AI_STOCK_ROLE_TAGS_READ).join(' ')));
+        const first = new Set(stemList(((_photo_tags1 = photo.tags) != null ? _photo_tags1 : []).slice(0, AI_STOCK_ROLE_TAGS_READ).join(' ')));
         if (((_judgement_roleScene1 = judgement.roleScene) == null ? void 0 : _judgement_roleScene1.length) && !judgement.roleScene.some((stem)=>first.has(stem))) return 0;
-        const read = new Set(stemList(((_photo_tags1 = photo.tags) != null ? _photo_tags1 : []).slice(0, ALT_TAGS_READ).join(' ')));
+        const read = new Set(stemList(((_photo_tags2 = photo.tags) != null ? _photo_tags2 : []).slice(0, ALT_TAGS_READ).join(' ')));
         if (((_judgement_roleRefuse1 = judgement.roleRefuse) != null ? _judgement_roleRefuse1 : []).some((stem)=>read.has(stem))) return 0;
     }
     // A Blue Ridge couple is never on a beach, however its later tags name a mountain (AGL-3942).
     if ((_judgement_away = judgement.away) == null ? void 0 : _judgement_away.length) {
-        var _photo_tags2;
-        const read = new Set(stemList(((_photo_tags2 = photo.tags) != null ? _photo_tags2 : []).slice(0, ALT_TAGS_READ).join(' ')));
+        var _photo_tags3;
+        const read = new Set(stemList(((_photo_tags3 = photo.tags) != null ? _photo_tags3 : []).slice(0, ALT_TAGS_READ).join(' ')));
         if (judgement.away.some((stem)=>read.has(stem))) return 0;
     }
     // A wedding day shows its people: a close-up of roses tagged "wedding" never fills it.
@@ -2965,7 +4139,8 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     const kinNamed = kin.some((phrase)=>among(hit.phrases, phrase));
     const kinLead = kin.some((phrase)=>among(hit.leadPhrases, phrase));
     const required = stemList((_judgement_requires = judgement.requires) != null ? _judgement_requires : '');
-    const category = ((_judgement_category = judgement.category) != null ? _judgement_category : []).flatMap(stemList);
+    // A two-word name stays whole: "dirt bike", never "bike" (AGL-4065).
+    const category = ((_judgement_category = judgement.category) != null ? _judgement_category : []).map(stemPhrase).filter(Boolean);
     const anyOf = category.length ? [
         ...new Set([
             ...required,
@@ -2978,21 +4153,36 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     if (demanded && !kinNamed && !meets) return 0;
     const object = (_judgement_object = judgement.object) != null ? _judgement_object : judgement.subject ? aiStockObjectWord(judgement.subject) : '';
     const domain = ((_judgement_domain = judgement.domain) != null ? _judgement_domain : []).filter((stem)=>stem !== object);
+    // The business's own world, which a picture that is not of a thing names (AGL-4065).
+    const own = ((_judgement_world = judgement.world) == null ? void 0 : _judgement_world.length) ? judgement.world.filter((stem)=>stem !== object) : domain;
     // 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 = demanded || kinNamed || domain.some((stem)=>hit.all.has(stem));
+    const ownWorld = demanded || kinNamed || own.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;
+    // One of its first tags is OF the business's own world (AGL-4092): "tacos",
+    // "street tacos", "dirt bike" lead with it; "taco bowl", "body part" and a
+    // man posing with a "motorcycle" for a motocross team do not.
+    if (judgement.leadOwn && own.length && !kinLead && !leadsWithWorld((_photo_tags = photo.tags) != null ? _photo_tags : [], new Set(own), new Set(domain))) return 0;
+    // A cat, a toy or a bare foot leads it, and nothing of the business's own world does (AGL-4092).
+    if (((_judgement_oddLeads = judgement.oddLeads) == null ? void 0 : _judgement_oddLeads.length) && own.length) {
+        var _photo_tags4;
+        const first = termsOf(((_photo_tags4 = photo.tags) != null ? _photo_tags4 : []).slice(0, 3));
+        if (judgement.oddLeads.some((stem)=>first.has(stem)) && !own.some((stem)=>first.has(stem))) return 0;
+    }
     // The first tag alone, never the page's address: Pixabay's slug repeats a
     // late tag ("coffee-latte-art-candle-…"). A site whose words name no world
     // holds its hero to none.
+    // The business's own world, never every word of its type (AGL-4065): "race
+    // car" named "race" of "Amateur motocross race team: … race schedule".
     const worldStems = new Set([
         ...anyOf,
         ...required,
-        ...domain
+        ...own
     ]);
     if (judgement.first && (worldStems.size || kin.length)) {
-        const firstWorld = hit.firstPhrase.split(' ').some((stem)=>worldStems.has(stem)) || kin.some((phrase)=>among([
+        const firstWorld = withPairs(hit.firstPhrase.split(' ').filter(Boolean)).some((stem)=>worldStems.has(stem)) || kin.some((phrase)=>among([
                 hit.firstPhrase
             ], phrase));
         if (!firstWorld) return 0;
@@ -3011,14 +4201,25 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         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;
+        // The business's own world, never any word of its type (AGL-4092): a cat
+        // tagged "hungry" named "breakfast", and a European alley "street", of
+        // "Taco food trailer: street and breakfast tacos".
+        if (own.length && !ownWorld && !phrased) return 0;
         score += leading ? 4 : 2;
         if (kinNamed) score += 3;
         if (firstNamed(kin.length ? kin : [
             object
         ])) score += 1;
-    } else if (domain.length) {
-        if (!world) return 0;
+        // A product's photo is OF it: named by its first or second tag, over one naming it fourth (AGL-4092).
+        if (judgement.product) {
+            var _photo_tags5;
+            const firstTwo = ((_photo_tags5 = photo.tags) != null ? _photo_tags5 : []).slice(0, 2).map((tag)=>stemList(tag).join(' '));
+            if ((kin.length ? kin : [
+                object
+            ]).some((phrase)=>among(firstTwo, phrase))) score += 2;
+        }
+    } else if (own.length) {
+        if (!ownWorld) return 0;
     }
     if (leadAny.length && firstNamed(leadAny)) score += 1;
     if (phrased) score += 3;
@@ -3032,7 +4233,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     // attorney" over "lawyers, personal injury, accident" (AGL-3856): a second
     // of them naming its world says it is of that world, not of something else.
     if (judgement.first && worldStems.size) {
-        const said = hit.leadPhrases.slice(0, -1).filter((phrase)=>phrase.split(' ').some((stem)=>worldStems.has(stem)));
+        const said = hit.leadPhrases.slice(0, -1).filter((phrase)=>withPairs(phrase.split(' ')).some((stem)=>worldStems.has(stem)));
         if (said.length >= 2) score += 0.25;
     }
     return Math.max(score, 0.5);
@@ -3076,13 +4277,15 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * A search's ranked hits with those of a shoot no slot shows yet first among
  * the best (AGL-3856): a team's three cards are three people where the
  * library has them, never one model three times while another fits as well.
- * Every other order is kept.
- */ export function aiStockFreshShootsFirst(ranked, shown, judgement) {
+ * Every other order is kept. A product's are of a shoot no slot shows yet
+ * first among ALL its accepted hits (`whole`, AGL-4092): Berm & Bolt's two
+ * tires were one contributor's shoot, 32 uploads apart.
+ */ export function aiStockFreshShootsFirst(ranked, shown, judgement, options = {}) {
     if (!shown.length || ranked.length < 2) return [
         ...ranked
     ];
     const best = aiStockRelevance(ranked[0], judgement);
-    const top = ranked.filter((photo)=>aiStockRelevance(photo, judgement) === best);
+    const top = options.whole ? ranked : ranked.filter((photo)=>aiStockRelevance(photo, judgement) === best);
     const fresh = top.filter((photo)=>!shown.some((other)=>aiStockSameShoot(photo, other)));
     if (!fresh.length || fresh[0] === ranked[0]) return [
         ...ranked
@@ -3217,7 +4420,8 @@ function jobPhotos(key) {
 /**
  * Makers' names a tag gives, never what a photo shows to someone who cannot
  * see it (AGL-3856): "A photo-camera and a sony".
- */ const BRANDS = words('sony canon cannon nikon fujifilm fuji leica olympus panasonic kodak polaroid hasselblad pentax gopro dji ' + 'apple iphone ipad macbook imac samsung huawei android google microsoft windows dell lenovo nintendo playstation ' + 'xbox nike adidas puma reebok peloton bmw mercedes audi porsche ferrari lamborghini tesla ford toyota honda ' + 'volkswagen vw jeep chevrolet coca-cola pepsi starbucks mcdonalds ikea lego barbie disney altman ' + 'petri zenit praktica yashica minolta mamiya rolleiflex voigtlander contax ricoh konica lomo lomography holga zeiss');
+ */ const BRANDS = words('sony canon cannon nikon fujifilm fuji leica olympus panasonic kodak polaroid hasselblad pentax gopro dji ' + 'apple iphone ipad macbook imac samsung huawei android google microsoft windows dell lenovo nintendo playstation ' + 'xbox nike adidas puma reebok peloton bmw mercedes audi porsche ferrari lamborghini tesla ford toyota honda ' + 'volkswagen vw jeep chevrolet coca-cola pepsi starbucks mcdonalds ikea lego barbie disney altman ' + // The vehicle makers a moto site's photos are tagged with (AGL-4065), and its gear's and tires' (AGL-4092).
+'yamaha kawasaki suzuki ktm ducati harley harley-davidson husqvarna gasgas nissan subaru mazda chevy dodge reebok ' + `${GEAR_MAKER_WORDS.join(' ')} ` + 'petri zenit praktica yashica minolta mamiya rolleiflex voigtlander contax ricoh konica lomo lomography holga zeiss');
 /** Stopwords a description still says, as the people a photo shows: "a family", "a person". */ const SAID_PEOPLE = words('people person family');
 /** Words ending in "-ing" that are things, and take an article: "a wedding", "a ring". */ const COUNTED_ING = words('wedding ring earring building painting drawing ceiling string swing king sibling wing dumpling pudding sapling');
 /** "-ing" words that are things, and take no article: "clothing". */ const UNCOUNTED_ING = words('clothing bedding frosting icing flooring stuffing seasoning filling');
@@ -3658,6 +4862,9 @@ const EXTENSIONS = {
     'kin',
     'lead',
     'leadWorld',
+    'leadOwn',
+    'oddLeads',
+    'served',
     'first',
     'category',
     'strict',
@@ -4339,13 +5546,16 @@ const EXTENSIONS = {
     const base = aiStockSiteTerms(entry.subject);
     if (!((_entry_kin = entry.kin) == null ? void 0 : _entry_kin.length)) return base;
     const kin = entry.kin.map(aiStockStem);
+    const domain = [
+        ...new Set([
+            ...base.domain,
+            ...kin
+        ])
+    ];
     return _extends({}, base, {
-        domain: [
-            ...new Set([
-                ...base.domain,
-                ...kin
-            ])
-        ],
+        domain,
+        // The kind's own world is all of it: its subject and its kin (AGL-4065).
+        lead: domain,
         broad: [
             ...(_entry_broad = entry.broad) != null ? _entry_broad : base.broad
         ],
@@ -4880,7 +6090,7 @@ const WORKSPACE = {
  * "freelencing", which no library tags, so its cover hero searched it, found
  * nothing, and shipped a flat dark band with no photo.
  */ export function aiStockWiderTerms(terms, kind) {
-    var _STARTER_KINDS_starter, _aiStockKindGenericTerms, _STARTER_GENERIC_KIND_starter;
+    var _STARTER_KINDS_starter, _STARTER_GENERIC_KIND_starter;
     const rungs = [];
     const seen = new Set([
         JSON.stringify([
@@ -4890,8 +6100,11 @@ const WORKSPACE = {
             ]
         ])
     ]);
-    const add = (rung, found)=>{
+    // An outdoor or a trade world never widens to an office's photos (AGL-4065).
+    const outdoor = aiStockWorldIsOutdoorOrTrade(terms);
+    const add = (rung, of, found)=>{
         if (!found || !found.broad.length) return;
+        if (outdoor && OFFICE_KINDS.has(of)) return;
         const key = JSON.stringify([
             found.craft,
             found.broad
@@ -4904,15 +6117,42 @@ const WORKSPACE = {
         });
     };
     if (!aiStockWorldIsUnlisted(terms)) {
-        if (kind && worldOfKind(terms, kind)) add('generic', aiStockKindGenericTerms(kind));
+        if (kind && worldOfKind(terms, kind)) add('generic', kind, aiStockKindGenericTerms(kind));
         return rungs;
     }
     const starter = starterOfKind(kind);
-    if (kind) add('kind', aiStockKindTerms(kind));
-    add('starter', aiStockKindTerms((_STARTER_KINDS_starter = STARTER_KINDS[starter]) != null ? _STARTER_KINDS_starter : 'business'));
-    add('generic', (_aiStockKindGenericTerms = aiStockKindGenericTerms(kind)) != null ? _aiStockKindGenericTerms : aiStockKindGenericTerms((_STARTER_GENERIC_KIND_starter = STARTER_GENERIC_KIND[starter]) != null ? _STARTER_GENERIC_KIND_starter : 'business'));
+    const starterKind = (_STARTER_KINDS_starter = STARTER_KINDS[starter]) != null ? _STARTER_KINDS_starter : 'business';
+    if (kind) add('kind', kind, aiStockKindTerms(kind));
+    add('starter', starterKind, aiStockKindTerms(starterKind));
+    const generic = KIND_GENERIC[kind] ? kind : (_STARTER_GENERIC_KIND_starter = STARTER_GENERIC_KIND[starter]) != null ? _STARTER_GENERIC_KIND_starter : 'business';
+    add('generic', generic, aiStockKindGenericTerms(generic));
     return rungs;
 }
+/**
+ * The kinds of site whose photos are an office, a desk or a workspace
+ * (AGL-4065): what a landscaper, a roofer or a taco trailer never widens to.
+ */ const OFFICE_KINDS = new Set([
+    'business',
+    'landing',
+    'professional',
+    'personal',
+    'coming-soon',
+    'studio'
+]);
+/**
+ * Words of a world whose work is done outdoors, on a vehicle, with tools or
+ * over food (AGL-4065), as stems: such a world's pictures are never an
+ * office's. The Bluebonnet Yard & Landscape start, a world the module did not
+ * list, picked as Business & services, opened every page on an office.
+ */ const OUTDOOR_AND_TRADE_STEMS = new Set(('landscaping landscaper landscape lawn garden gardening yard roof roofing roofer fence fencing deck patio construction ' + 'contractor farm ranch moto motorcycle motocross bike dirt atv truck trailer tow towing auto car mechanic food ' + 'restaurant kitchen taco plumbing plumber electrician electrical hvac painting painter handyman carpentry carpenter ' + 'tree pool pest cleaning junk excavation concrete masonry welding').split(' ').map(aiStockStem));
+/** Whether a site's own world is outdoors, on a vehicle, with tools or over food ({@link OUTDOOR_AND_TRADE_STEMS}). */ export function aiStockWorldIsOutdoorOrTrade(terms) {
+    var _terms_lead;
+    const own = [
+        ...(_terms_lead = terms.lead) != null ? _terms_lead : terms.domain,
+        ...stemList(`${terms.business} ${terms.craft}`)
+    ];
+    return own.some((term)=>term.split(' ').some((stem)=>OUTDOOR_AND_TRADE_STEMS.has(stem)));
+}
 /**
  * The first word of a text that names a craft {@link CRAFT_KIN} lists, as
  * its table writes it: "gym" of "Synchronicity Gym", "law" of "Hartwell
@@ -4949,6 +6189,147 @@ const WORKSPACE = {
     if (!aiLayoutSpeaksOtherThanEnglish(input.language)) return '';
     return aiStockBusinessNoun(input.business) || aiStockPhotoWordsSubject((_input_photoWords = input.photoWords) != null ? _input_photoWords : '') || ((_input_kindWords = input.kindWords) != null ? _input_kindWords : '').trim();
 }
+/**
+ * How a search's hits are judged for a slot (AGL-3660), as the source judges
+ * them: by the search's own words, held to the world it was asked for — the
+ * site's own (`site`), or a wider one where the site's found nothing
+ * (`world`, AGL-3923). What lets a sensitive topic, an animal or a body part
+ * in is always the site's own words. On a site for adults alone no hit names
+ * a child; a portrait of one of the business's people names an adult, never
+ * leads with a child, and is preferred in its role (AGL-3856). Any other
+ * picture never leads with an animal, a toy or a bare body part its words
+ * and the brief do not name, unless its first tags name the business's own
+ * world too (AGL-4092): Pit Row Tacos' "Come hungry" took a cat. Pure.
+ */ export function aiStockJudgementFor(slot, request, subject, site, sectionName = '', world = site) {
+    var _request_refuse, _ref, _request_subject, _request_shun, _request_refuseLead;
+    var _slot_product, _world_lead, _request_allow, _request_shun1, _request_leadAny, _request_served, _request_needs, _request_refuseLead1, _request_away, _request_needs1, _role_scene, _role_refuse;
+    const refuse = [
+        ...(_request_refuse = request.refuse) != null ? _request_refuse : [],
+        ...site.adults ? CHILD_STEMS : []
+    ];
+    const role = slot.people ? aiStockPeopleRole(slot.alt, sectionName) : null;
+    // A portrait's face is its own, and a craft whose pictures are people at a moment shows their hands and rings (AGL-4092).
+    const oddLeads = slot.people ? [] : aiStockOddLeads([
+        slot.alt,
+        ...(_ref = (_slot_product = slot.product) == null ? void 0 : _slot_product.subjects) != null ? _ref : [],
+        sectionName,
+        ...site.named
+    ], {
+        body: slot.role !== 'about' && !site.scenes
+    });
+    return _extends({
+        subject: (_request_subject = request.subject) != null ? _request_subject : request.broad ? '' : subject,
+        domain: world.domain
+    }, ((_world_lead = world.lead) == null ? void 0 : _world_lead.length) ? {
+        world: world.lead
+    } : {}, {
+        strict: slot.role === 'gallery' && !request.broad || !!request.requires || !!request.strict,
+        named: ((_request_allow = request.allow) == null ? void 0 : _request_allow.length) ? [
+            ...new Set([
+                ...site.named,
+                ...request.allow
+            ])
+        ] : site.named,
+        rivals: world.rivals
+    }, world.shun.length || ((_request_shun1 = request.shun) == null ? void 0 : _request_shun1.length) ? {
+        shun: [
+            ...new Set([
+                ...world.shun,
+                ...(_request_shun = request.shun) != null ? _request_shun : []
+            ])
+        ]
+    } : {}, world.shunLead.length ? {
+        shunLead: world.shunLead
+    } : {}, request.product ? {
+        product: true
+    } : {}, ((_request_leadAny = request.leadAny) == null ? void 0 : _request_leadAny.length) ? {
+        leadAny: request.leadAny
+    } : {}, request.requires ? {
+        requires: request.requires
+    } : {}, request.category ? {
+        category: request.category
+    } : {}, request.object ? {
+        object: request.object
+    } : {}, request.kin ? {
+        kin: request.kin
+    } : {}, request.lead ? {
+        lead: true
+    } : {}, request.leadWorld ? {
+        leadWorld: true
+    } : {}, request.leadOwn ? {
+        leadOwn: true
+    } : {}, ((_request_served = request.served) == null ? void 0 : _request_served.length) ? {
+        served: request.served
+    } : {}, request.first ? {
+        first: true
+    } : {}, refuse.length ? {
+        refuse: [
+            ...new Set(refuse)
+        ]
+    } : {}, ((_request_needs = request.needs) == null ? void 0 : _request_needs.length) ? {
+        needs: request.needs
+    } : {}, ((_request_refuseLead1 = request.refuseLead) == null ? void 0 : _request_refuseLead1.length) ? {
+        refuseLead: request.refuseLead
+    } : {}, ((_request_away = request.away) == null ? void 0 : _request_away.length) ? {
+        away: request.away
+    } : {}, oddLeads.length ? {
+        oddLeads
+    } : {}, request.worldless ? {
+        domain: [],
+        rivals: []
+    } : {}, slot.people ? _extends({
+        needs: ((_request_needs1 = request.needs) == null ? void 0 : _request_needs1.length) ? request.needs : (role == null ? void 0 : role.required) ? role.kin : ADULT_PEOPLE_STEMS,
+        refuseLead: [
+            ...new Set([
+                ...CHILD_STEMS,
+                ...(_request_refuseLead = request.refuseLead) != null ? _request_refuseLead : []
+            ])
+        ]
+    }, role ? {
+        roles: role.kin
+    } : {}, (role == null ? void 0 : (_role_scene = role.scene) == null ? void 0 : _role_scene.length) ? {
+        roleScene: role.scene
+    } : {}, (role == null ? void 0 : (_role_refuse = role.refuse) == null ? void 0 : _role_refuse.length) ? {
+        roleRefuse: aiStockRoleRefusals(role, slot.alt)
+    } : {}) : {});
+}
+/**
+ * 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. A picture that is not a
+ * hero nor a product takes only a photo OF the business's own world among its
+ * first tags (AGL-4092): a taco trailer's "Race day" took a chicken salad
+ * tagged "taco bowl". Pure.
+ */ export function aiStockCraftSearches(slot, world) {
+    // A portfolio's record of the work is never filled by the craft's own
+    // photos (AGL-3856), nor is any picture of a site that shows its work (AGL-3942).
+    if (!world.core.length || aiStockShowsTheWork(slot, world) || aiStockShowsItsWork(slot, world)) return [];
+    const orientation = aiStockOrientation(slot.aspect);
+    const size = slot.role === 'hero' ? {
+        minWidth: 1600
+    } : orientation === 'vertical' ? {
+        minHeight: 900
+    } : {
+        minWidth: 900
+    };
+    return world.broad.map((query)=>{
+        var _world_held;
+        return _extends({
+            query: clip(query),
+            orientation
+        }, size, {
+            broad: true,
+            category: world.core
+        }, slot.role === 'hero' ? {
+            first: true
+        } : slot.product && !((_world_held = world.held) == null ? void 0 : _world_held.length) ? {} : {
+            leadOwn: true
+        }, slot.product ? {
+            product: true,
+            tier: 'weak'
+        } : {});
+    });
+}
 /**
  * The source for one page, or `null` when this deployment has no stock
  * photo library or no media door, which leaves every slot to the starters.
@@ -5126,120 +6507,10 @@ const WORKSPACE = {
      * hit names a child; a portrait of one of the business's people names an
      * adult, never leads with a child, and is preferred in its role (AGL-3856).
      */ const judgementFor = (slot, request, subject)=>{
-            var _request_refuse, _input_sectionNames_slot_sectionIndex, _worldOf_get, _request_refuseLead;
-            var _request_needs, _role_scene, _role_refuse;
-            const refuse = [
-                ...(_request_refuse = request.refuse) != null ? _request_refuse : [],
-                ...terms.adults ? CHILD_STEMS : []
-            ];
-            const role = slot.people ? aiStockPeopleRole(slot.alt, (_input_sectionNames_slot_sectionIndex = input.sectionNames[slot.sectionIndex]) != null ? _input_sectionNames_slot_sectionIndex : '') : null;
-            return _extends({}, judgementOf(slot, request, subject, (_worldOf_get = worldOf.get(request)) != null ? _worldOf_get : terms), refuse.length ? {
-                refuse: [
-                    ...new Set(refuse)
-                ]
-            } : {}, slot.people ? _extends({
-                needs: ((_request_needs = request.needs) == null ? void 0 : _request_needs.length) ? request.needs : (role == null ? void 0 : role.required) ? role.kin : ADULT_PEOPLE_STEMS,
-                refuseLead: [
-                    ...new Set([
-                        ...CHILD_STEMS,
-                        ...(_request_refuseLead = request.refuseLead) != null ? _request_refuseLead : []
-                    ])
-                ]
-            }, role ? {
-                roles: role.kin
-            } : {}, (role == null ? void 0 : (_role_scene = role.scene) == null ? void 0 : _role_scene.length) ? {
-                roleScene: role.scene
-            } : {}, (role == null ? void 0 : (_role_refuse = role.refuse) == null ? void 0 : _role_refuse.length) ? {
-                roleRefuse: aiStockRoleRefusals(role, slot.alt)
-            } : {}) : {});
-        };
-        /**
-     * A search's own judgement, as its words set it, held to the world it was
-     * asked for: the site's own, or a wider one where the site's found nothing
-     * (AGL-3923). What lets a sensitive topic in is always the site's own words.
-     */ const judgementOf = (slot, request, subject, world)=>{
-            var _request_subject, _request_shun;
-            var _request_allow, _request_shun1, _request_leadAny, _request_refuse, _request_needs, _request_refuseLead, _request_away;
-            return _extends({
-                subject: (_request_subject = request.subject) != null ? _request_subject : request.broad ? '' : subject,
-                domain: world.domain,
-                strict: slot.role === 'gallery' && !request.broad || !!request.requires || !!request.strict,
-                named: ((_request_allow = request.allow) == null ? void 0 : _request_allow.length) ? [
-                    ...new Set([
-                        ...terms.named,
-                        ...request.allow
-                    ])
-                ] : terms.named,
-                rivals: world.rivals
-            }, world.shun.length || ((_request_shun1 = request.shun) == null ? void 0 : _request_shun1.length) ? {
-                shun: [
-                    ...new Set([
-                        ...world.shun,
-                        ...(_request_shun = request.shun) != null ? _request_shun : []
-                    ])
-                ]
-            } : {}, world.shunLead.length ? {
-                shunLead: world.shunLead
-            } : {}, request.product ? {
-                product: true
-            } : {}, ((_request_leadAny = request.leadAny) == null ? void 0 : _request_leadAny.length) ? {
-                leadAny: request.leadAny
-            } : {}, request.requires ? {
-                requires: request.requires
-            } : {}, request.category ? {
-                category: request.category
-            } : {}, request.object ? {
-                object: request.object
-            } : {}, request.kin ? {
-                kin: request.kin
-            } : {}, request.lead ? {
-                lead: true
-            } : {}, request.leadWorld ? {
-                leadWorld: true
-            } : {}, request.first ? {
-                first: true
-            } : {}, ((_request_refuse = request.refuse) == null ? void 0 : _request_refuse.length) ? {
-                refuse: request.refuse
-            } : {}, ((_request_needs = request.needs) == null ? void 0 : _request_needs.length) ? {
-                needs: request.needs
-            } : {}, ((_request_refuseLead = request.refuseLead) == null ? void 0 : _request_refuseLead.length) ? {
-                refuseLead: request.refuseLead
-            } : {}, ((_request_away = request.away) == null ? void 0 : _request_away.length) ? {
-                away: request.away
-            } : {}, request.worldless ? {
-                domain: [],
-                rivals: []
-            } : {});
-        };
-        /**
-     * 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, world = terms)=>{
-            // A portfolio's record of the work is never filled by the craft's own
-            // photos (AGL-3856), nor is any picture of a site that shows its work (AGL-3942).
-            if (!world.core.length || aiStockShowsTheWork(slot, world) || aiStockShowsItsWork(slot, world)) return [];
-            const orientation = aiStockOrientation(slot.aspect);
-            const size = slot.role === 'hero' ? {
-                minWidth: 1600
-            } : orientation === 'vertical' ? {
-                minHeight: 900
-            } : {
-                minWidth: 900
-            };
-            return world.broad.map((query)=>_extends({
-                    query: clip(query),
-                    orientation
-                }, size, {
-                    broad: true,
-                    category: world.core
-                }, slot.role === 'hero' ? {
-                    first: true
-                } : {}, slot.product ? {
-                    product: true,
-                    tier: 'weak'
-                } : {}));
+            var _input_sectionNames_slot_sectionIndex, _worldOf_get;
+            return aiStockJudgementFor(slot, request, subject, terms, (_input_sectionNames_slot_sectionIndex = input.sectionNames[slot.sectionIndex]) != null ? _input_sectionNames_slot_sectionIndex : '', (_worldOf_get = worldOf.get(request)) != null ? _worldOf_get : terms);
         };
+        const craftSearches = (slot, world = terms)=>aiStockCraftSearches(slot, world);
         /**
      * A slot's searches once its own world found it nothing (AGL-3923), in
      * order: the kind of site's world, the starter's, the slot's own words
@@ -5259,10 +6530,16 @@ const WORKSPACE = {
             };
             for (const { rung, terms: world } of wider){
                 if (rung === 'generic') continue;
+                // A wider world is the site's only as a kind of site: its photos are held to it as before (AGL-4092).
                 ask(world, [
                     ...aiStockSearchesFor(slot, world, subject, part, sectionName),
                     ...craftSearches(slot, world)
-                ]);
+                ].map((_0)=>{
+                    let { leadOwn: _own } = _0, request = _object_without_properties_loose(_0, [
+                        "leadOwn"
+                    ]);
+                    return request;
+                }));
             }
             const orientation = aiStockOrientation(slot.aspect);
             const size = slot.role === 'hero' ? {
@@ -5325,15 +6602,21 @@ const WORKSPACE = {
             const subject = english ? '' : aiStockSubjectWords(slot.alt, sectionName);
             let choice = null;
             const requests = [
-                ...slot.product ? aiStockProductSearches(slot, terms.craft, terms.domain, {
+                ...slot.product ? aiStockProductSearches(slot, terms.craft, terms.domain, _extends({
                     broad: terms.broad,
                     core: terms.core
-                }) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName), sectionName),
+                }, terms.held ? {
+                    held: terms.held
+                } : {}, terms.leadWord ? {
+                    leadWord: terms.leadWord
+                } : {})) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName), sectionName),
                 ...craftSearches(slot)
             ];
+            /** Whether the library answered any of the slot's own searches with a photo at all (AGL-4065). */ let knew = false;
             /** 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) return null;
+                if (found.length && !worldOf.has(request)) knew = true;
                 const blocked = new Set();
                 if (!repeat) {
                     for (const key of claimed)blocked.add(key);
@@ -5349,8 +6632,12 @@ const WORKSPACE = {
                 }
                 const judgement = judgementFor(slot, request, subject);
                 const ranked = aiStockRank(found, blocked, `${input.seed}:${index}:${request.query}`, judgement);
-                // A team's portraits are of different people where the hits allow (AGL-3856).
-                return slot.people && !repeat ? aiStockFreshShootsFirst(ranked, shown, judgement) : ranked;
+                // A team's portraits are of different people where the hits allow (AGL-3856),
+                // and a shop's products of different shoots (AGL-4092).
+                if (repeat || !(slot.people || slot.product)) return ranked;
+                return aiStockFreshShootsFirst(ranked, shown, judgement, slot.product ? {
+                    whole: true
+                } : {});
             };
             /** The first of these searches with a hit to take: a new one, or one the job already shows. */ const choose = async (tried, repeat)=>{
                 for (const request of tried){
@@ -5383,44 +6670,54 @@ const WORKSPACE = {
             const sure = slot.product ? requests.filter((request)=>request.tier !== 'weak') : requests;
             const unsure = slot.product ? requests.filter((request)=>request.tier === 'weak') : [];
             // 3. Nothing of its own world at all: the wider worlds (AGL-3923), new
-            //    and then, for a hero, one the job already shows.
+            //    and then, for a hero, one the job already shows. A listed world
+            //    widens only where the library knew nothing of it (AGL-4065): one
+            //    it answered with photos it turned down keeps its slot without a
+            //    photo, never an office. A world of its own words alone still widens.
             const widened = widerSearches(slot, subject, sectionName);
             const phases = [
                 [
                     sure,
+                    false,
                     false
                 ],
                 ...repeats ? [
                     [
                         sure,
-                        true
+                        true,
+                        false
                     ]
                 ] : [],
                 ...unsure.length ? [
                     [
                         unsure,
+                        false,
                         false
                     ],
                     [
                         unsure,
-                        true
+                        true,
+                        false
                     ]
                 ] : [],
                 ...widened.length ? [
                     [
                         widened,
-                        false
+                        false,
+                        true
                     ]
                 ] : [],
                 ...widened.length && repeats ? [
                     [
                         widened,
+                        true,
                         true
                     ]
                 ] : []
             ];
-            for (const [tried, repeat] of phases){
+            for (const [tried, repeat, wide] of phases){
                 if (choice || signal.aborted) break;
+                if (wide && knew && !unlisted) break;
                 choice = await choose(tried, repeat);
             }
             choices.push(choice);