@aglyn/plugins-ai 1.0.0-beta.284 → 1.0.0-beta.287

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

@@ -140,6 +140,20 @@ 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.
  *
  * 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 +225,43 @@ 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');
+/**
+ * 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 +597,96 @@ 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.
+ */ 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'
+];
+/** 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(' ')));
+/**
+ * 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));
+    return termsOf([
+        ...tags,
+        (_photo_alt = photo.alt) != null ? _photo_alt : '',
+        pageSlug(photo.pageUrl)
+    ]);
+}
 /**
  * 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 +875,73 @@ 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'
+        ]
     }
 ];
 /** 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 +1591,362 @@ 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 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'
+        ],
+        shunLead: [
+            'buffet',
+            'hotel',
+            'fine dining',
+            'chef',
+            'indian',
+            'potato',
+            'banquet',
+            'cafeteria',
+            'wedding'
+        ]
     }
 ];
 /** Lowercase words, letters only, without stopwords. */ function contentWords(text) {
@@ -1409,28 +1967,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 +2028,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 +2049,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 +2092,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 +2103,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 +2161,72 @@ 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 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));
     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
+    } : {}, {
         broad: [
             ...new Set(broad.map((query)=>query.trim()).filter(Boolean))
         ],
@@ -1559,12 +2247,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 +2266,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(' ');
 }
@@ -2550,7 +3263,7 @@ 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 _terms_core, _terms_leadWord, _terms_making, _ref, _ref1, _terms_setting, _terms_setting1, _ref2, _terms_maker, _terms_maker1, _ref3;
     var _aiStockPeopleRole, _slot_record, _slot_record1;
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
@@ -2596,7 +3309,16 @@ 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).
@@ -2627,21 +3349,51 @@ 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 ? [] : ofTheWorld ? [
         {
-            query: own(subject),
-            held: true
+            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,16 +3547,18 @@ 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) ? _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
@@ -2849,15 +3603,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(' '),
@@ -2891,6 +3647,11 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  */ 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).
+    const makers = aiStockMakerTerms(photo);
+    if ([
+        ...MAKER_STEMS
+    ].some((maker)=>makers.has(maker) && !site.has(maker))) return true;
     return SENSITIVE_STEMS.some((topic)=>[
             ...topic.words
         ].some((word)=>found.has(word)) && ![
@@ -2909,7 +3670,7 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
  * 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_roleScene, _judgement_roleRefuse, _judgement_away, _judgement_world;
     const hit = hitWords(photo);
     if (hit.rejected) return 0;
     if (aiStockSensitive(photo, judgement.named)) return 0;
@@ -2965,7 +3726,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 +3740,26 @@ 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;
     // 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;
@@ -3017,8 +3784,8 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         if (firstNamed(kin.length ? kin : [
             object
         ])) score += 1;
-    } else if (domain.length) {
-        if (!world) return 0;
+    } else if (own.length) {
+        if (!ownWorld) return 0;
     }
     if (leadAny.length && firstNamed(leadAny)) score += 1;
     if (phrased) score += 3;
@@ -3032,7 +3799,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);
@@ -3217,7 +3984,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).
+'yamaha kawasaki suzuki ktm ducati harley harley-davidson husqvarna gasgas nissan subaru mazda chevy dodge reebok ' + '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');
@@ -4339,13 +5107,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 +5651,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 +5661,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 +5678,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
@@ -5159,10 +5960,13 @@ const WORKSPACE = {
      * (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;
+            var _world_lead, _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,
+                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([
@@ -5331,9 +6135,11 @@ const WORKSPACE = {
                 }) : 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);
@@ -5383,44 +6189,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);