@aglyn/plugins-ai 1.0.0-beta.263 → 1.0.0-beta.266

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

@@ -132,6 +132,14 @@ import { aiStockBusinessNoun } from "./ai-stock-business-nouns.js";
  *    ("wedding" of "a wedding and portrait photographer") is not the craft;
  *    and a hero whose second tag names the world too leads one whose first
  *    alone does.
+ * 9. **A world from the name** (the beta.261 Synchronicity Gym start,
+ *    AGL-3856: its business type "a local service business" named no world,
+ *    so its hero searched nothing and was left a black scrim, and its
+ *    closing band's "Ready to train" took a subway train). A business type
+ *    that names no world takes the craft its name, else its audience, names
+ *    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.
  *
  * 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
@@ -1208,7 +1216,8 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'boxer',
             'beach',
             'circus',
-            // Another sport's ball, never "medicine ball": a basketball court covered a deadlift night (AGL-3864).
+            // Another sport's ball, never "medicine ball": a basketball court covered a deadlift night (AGL-3864),
+            // a cricket ball on a wooden court another (AGL-3856).
             'basketball',
             'football',
             'soccer',
@@ -1217,7 +1226,58 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'tennis',
             'golf',
             'rugby',
-            'hockey'
+            'hockey',
+            'cricket',
+            'squash',
+            'badminton',
+            'shuttlecock',
+            'bowling',
+            'billiards',
+            'snooker',
+            'pool',
+            'lacrosse',
+            'softball',
+            'handball',
+            'pingpong',
+            'pong'
+        ],
+        // A training word's other senses (AGL-3856): "train" is a railway's, "lift"
+        // an elevator's or a ski lift's, "press" a newspaper's, "row" a boat's. The
+        // beta.261 Synchronicity Gym's closing band, "Ready to train", took a
+        // subway train at a station.
+        shun: [
+            'railway',
+            'railroad',
+            'rail',
+            'locomotive',
+            'subway',
+            'metro',
+            'tram',
+            'tramway',
+            'commuter',
+            'freight',
+            'transport',
+            'transportation',
+            'traffic',
+            'vehicle',
+            'bus',
+            'truck',
+            'airplane',
+            'aircraft',
+            'elevator',
+            'escalator',
+            'chairlift',
+            'forklift',
+            'crane',
+            'newspaper',
+            'journalism',
+            'journalist',
+            'printing',
+            'boat',
+            'ship',
+            'canoe',
+            'kayak',
+            'sailboat'
         ]
     },
     {
@@ -1230,6 +1290,20 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
             'photo',
             'photograph'
         ],
+        scenes: true,
+        maker: [
+            'photographer',
+            'photographers',
+            'camera',
+            'cameras',
+            'lens',
+            'lenses',
+            'tripod',
+            'dslr',
+            'slr',
+            'journalist',
+            'paparazzi'
+        ],
         kin: [
             'photographer',
             'photography',
@@ -1415,7 +1489,7 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         });
     }
     if (!broad.length) broad.push(business, craft);
-    return {
+    return _extends({
         business,
         craft,
         domain: [
@@ -1426,7 +1500,20 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         ],
         making: [
             ...new Set(makingSearches)
-        ],
+        ]
+    }, groups.some((group)=>group.scenes) ? {
+        scenes: true
+    } : {}, groups.some((group)=>{
+        var _group_maker;
+        return (_group_maker = group.maker) == null ? void 0 : _group_maker.length;
+    }) ? {
+        maker: [
+            ...new Set(groups.flatMap((group)=>{
+                var _group_maker;
+                return (_group_maker = group.maker) != null ? _group_maker : [];
+            }).map(aiStockStem))
+        ]
+    } : {}, {
         named: [
             ...new Set(stemList(businessType))
         ],
@@ -1440,7 +1527,7 @@ const words = (list)=>new Set(list.trim().split(/\s+/));
         shunLead: [
             ...shunLead
         ]
-    };
+    });
 }
 /** A phrase's content words without its filler; all filler, and nothing is left. */ function subjectOf(list) {
     return list.filter((word)=>!FILLER.has(word));
@@ -1487,6 +1574,560 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     if (aiStorefrontSays('story', sectionName) || saysMadeByHand(slot.alt) || saysMadeByHand(sectionName)) return 'story';
     return undefined;
 }
+/**
+ * The people a picture of a moment shows (AGL-3856): what its words name, the
+ * search that asks for them, the words a photo of them leads with, those of
+ * which it must name one anywhere, and what it never carries unless the
+ * words name it. A family session is never a bride.
+ */ const PEOPLE_SCENES = [
+    {
+        words: [
+            'family',
+            'families',
+            'kid',
+            'kids',
+            'child',
+            'children',
+            'newborn',
+            'baby',
+            'parent',
+            'parents',
+            'mother',
+            'father'
+        ],
+        query: ()=>'family',
+        subject: 'family',
+        lead: [
+            'family',
+            'families',
+            'child',
+            'children',
+            'kid',
+            'kids',
+            'mother',
+            'father',
+            'parents',
+            'mom',
+            'dad',
+            'daughter',
+            'son',
+            'baby',
+            'toddler'
+        ],
+        people: [
+            'family',
+            'child',
+            'children',
+            'kid',
+            'kids',
+            'mother',
+            'father',
+            'parent',
+            'parents',
+            'daughter',
+            'son',
+            'baby',
+            'toddler',
+            'mom',
+            'dad'
+        ],
+        shun: [
+            'bride',
+            'groom',
+            'bridal',
+            'wedding',
+            'newlywed',
+            'newlyweds',
+            'marriage'
+        ]
+    },
+    {
+        words: [
+            'wedding',
+            'weddings',
+            'elopement',
+            'elopements',
+            'elope',
+            'eloping',
+            'bride',
+            'brides',
+            'bridal',
+            'groom',
+            'engagement',
+            'engaged',
+            'couple',
+            'couples',
+            'newlywed',
+            'newlyweds',
+            'honeymoon',
+            'ceremony',
+            'ceremonies',
+            'reception',
+            'receptions',
+            'vows'
+        ],
+        query: (named)=>[
+                'wedding',
+                'weddings',
+                'bride',
+                'bridal',
+                'groom'
+            ].some((word)=>named.has(word)) ? 'wedding couple' : 'couple',
+        subject: 'couple',
+        lead: [
+            'couple',
+            'couples',
+            'bride',
+            'groom',
+            'wedding',
+            'newlyweds',
+            'lovers',
+            'elopement',
+            'bride and groom'
+        ],
+        people: [
+            'couple',
+            'bride',
+            'groom',
+            'newlywed',
+            'newlyweds',
+            'lovers',
+            'husband',
+            'wife',
+            'man',
+            'woman'
+        ],
+        shun: []
+    }
+];
+/**
+ * A portrait session (AGL-3856), read for a record's cover alone: "Milestone
+ * Portraits" is a person's portrait, never a cat's. A page's "portrait of the
+ * photographer" keeps its own words.
+ */ const PORTRAIT_SCENE = {
+    words: [
+        'portrait',
+        'portraits',
+        'headshot',
+        'headshots'
+    ],
+    query: ()=>'portrait',
+    subject: 'portrait',
+    lead: [
+        'portrait',
+        'woman',
+        'man',
+        'couple',
+        'person',
+        'people'
+    ],
+    people: [
+        'woman',
+        'women',
+        'man',
+        'men',
+        'couple',
+        'person',
+        'people',
+        'bride',
+        'groom',
+        'mother',
+        'father',
+        'family'
+    ],
+    shun: []
+};
+/**
+ * Words a photo of a child is tagged with (AGL-3856), as stems. Pixabay tags
+ * a schoolgirl "girl", "schoolgirl" or "school girl" far more often than
+ * "child", so a site for adults that names a school let children in: the
+ * beta.264 Brightpath Adult Learning Center's "Meet your teachers" showed a
+ * teen graduate, a schoolgirl and kids.
+ */ const CHILD_STEMS = [
+    ...new Set(('child children childhood kid kids baby babies toddler toddlers infant infants newborn boy boys girl girls ' + 'schoolgirl schoolgirls schoolboy schoolboys schoolchild schoolchildren schoolkid schoolkids pupil pupils ' + 'teen teens teenager teenagers teenage preteen youth kindergarten preschool').split(' ').map(aiStockStem))
+];
+/** Words of which a photo of one of the business's people names one: an adult, at work or in their role. */ const ADULT_PEOPLE_STEMS = [
+    ...new Set(('man men woman women adult adults businessman businesswoman businessmen professional ' + 'professionals staff worker workers employee employees team colleague colleagues coworker coworkers ' + 'teacher teachers instructor instructors tutor tutors lecturer professor educator faculty coach coaches ' + 'trainer trainers chef chefs cook baker barista doctor doctors dentist nurse nurses hygienist therapist ' + 'physician stylist hairdresser barber artist musician photographer entrepreneur founder owner manager ' + 'leader speaker volunteer volunteers mechanic electrician plumber carpenter craftsman technician').split(' ').map(aiStockStem))
+];
+/**
+ * The roles a list of the business's people names (AGL-3856): the words that
+ * name each, the words a photo of someone in it is tagged with, and the word
+ * a search for them leads with, where the libraries know one. A teacher is
+ * shown teaching, a coach coaching, never a student or a whistle. A team or
+ * a staff is anyone at work: its words are preferred, never required.
+ *
+ * A role whose photos are often of someone merely tagged with it carries the
+ * words of it being done, one of which the photo's first tags must name
+ * (`scene`), and the words of something else being done, which none of them
+ * may (`refuse`): the beta.265 Northgate Adult Learning Center's "Meet your
+ * teachers" placed a woman painting at an easel ("artist, teacher of
+ * drawing"), a model in a traditional dress ("woman, model, show, teacher")
+ * and an elderly man's portrait ("teacher, professor, man, senior").
+ */ const PEOPLE_ROLES = [
+    {
+        words: [
+            'instructor',
+            'teacher',
+            'tutor',
+            'educator',
+            'faculty',
+            'professor',
+            'lecturer',
+            'mentor'
+        ],
+        kin: [
+            'teacher',
+            'instructor',
+            'tutor',
+            'educator',
+            'professor',
+            'lecturer',
+            'teaching',
+            'lecture',
+            'faculty'
+        ],
+        query: 'teacher',
+        scene: [
+            'teaching',
+            'teach',
+            'classroom',
+            'class',
+            'lecture',
+            'lesson',
+            'lessons',
+            'tutor',
+            'tutoring',
+            'blackboard',
+            'chalkboard',
+            'whiteboard',
+            'board',
+            'seminar',
+            'student',
+            'students',
+            'learner',
+            'learners',
+            'presentation'
+        ],
+        refuse: [
+            'model',
+            'modeling',
+            'fashion',
+            'pose',
+            'posing',
+            'beauty',
+            'glamour',
+            'cosplay',
+            'artist',
+            'artists',
+            'painter',
+            'painting',
+            'paint',
+            'easel',
+            'canvas',
+            'draw',
+            'draws',
+            'drawing',
+            'calligraphy'
+        ]
+    },
+    {
+        words: [
+            'coach',
+            'trainer'
+        ],
+        kin: [
+            'coach',
+            'coaching',
+            'trainer',
+            'instructor'
+        ],
+        query: 'coach'
+    },
+    {
+        words: [
+            'chef',
+            'cook',
+            'baker'
+        ],
+        kin: [
+            'chef',
+            'cook',
+            'cooking',
+            'baker',
+            'baking'
+        ],
+        query: 'chef'
+    },
+    {
+        words: [
+            'stylist',
+            'barber',
+            'hairdresser',
+            'colorist'
+        ],
+        kin: [
+            'stylist',
+            'barber',
+            'hairdresser',
+            'hairstylist',
+            'haircut'
+        ],
+        query: 'hairdresser'
+    },
+    {
+        words: [
+            'doctor',
+            'dentist',
+            'hygienist',
+            'nurse',
+            'therapist',
+            'practitioner',
+            'physician'
+        ],
+        kin: [
+            'doctor',
+            'dentist',
+            'hygienist',
+            'nurse',
+            'therapist',
+            'physician',
+            'medical'
+        ]
+    },
+    {
+        words: [
+            'staff',
+            'team',
+            'crew',
+            'member',
+            'manager',
+            'founder',
+            'owner',
+            'partner',
+            'associate',
+            'employee'
+        ],
+        kin: [
+            'staff',
+            'team',
+            'worker',
+            'employee',
+            'colleague',
+            'coworker',
+            'professional',
+            'businessman',
+            'businesswoman',
+            'owner',
+            'manager'
+        ],
+        loose: true
+    }
+];
+/** How many of a photo's first tags show a role being done: "teacher, presentation, education, man, students" (AGL-3856). */ export const AI_STOCK_ROLE_TAGS_READ = 6;
+/**
+ * The role a person's words say, else the first of the other texts that names
+ * one (their list's name): "Online learning coach" of the "Instructors" list
+ * is a coach. `null` where none names a listed role.
+ */ export function aiStockPeopleRole(...texts) {
+    for (const text of texts){
+        var _role_query;
+        const named = new Set(stemList(text));
+        const role = PEOPLE_ROLES.find((entry)=>entry.words.some((word)=>named.has(aiStockStem(word))));
+        if (role) return _extends({
+            kin: [
+                ...new Set(role.kin.map(aiStockStem))
+            ],
+            query: (_role_query = role.query) != null ? _role_query : '',
+            required: !role.loose
+        }, role.scene ? {
+            scene: [
+                ...new Set(role.scene.map(aiStockStem))
+            ]
+        } : {}, role.refuse ? {
+            refuse: [
+                ...new Set(role.refuse.map(aiStockStem))
+            ]
+        } : {});
+    }
+    return null;
+}
+/** A role's refusals, less what the person's own words name: a "Drawing instructor" may be drawing. */ export function aiStockRoleRefusals(role, words) {
+    var _role_refuse;
+    const named = new Set(stemList(words));
+    return ((_role_refuse = role.refuse) != null ? _role_refuse : []).filter((stem)=>!named.has(stem));
+}
+/** A site's audience in its own words, when it is adults: "Adults finishing a high school diploma". */ const ADULT_AUDIENCE = /\b(?:adults?|grown[- ]?ups?|seniors?|retirees?|older (?:adults|people)|professionals|employees|workforce|job ?seekers)\b/i;
+/** Words that say a site is for children too, whatever else it says. */ const YOUNG_AUDIENCE = /\b(?:kids?|child(?:ren)?|teens?|teenagers?|youth|young people|famil(?:y|ies)|boys?|girls?|bab(?:y|ies)|toddlers?|k-12|elementary|middle school|preschool|kindergarten|pupils?)\b/i;
+/**
+ * Whether a site is for adults alone (AGL-3856), as its audience, its name
+ * or its business type says: "Adults finishing a high school diploma",
+ * "Brightpath Adult Learning Center". Then no photo of a child is placed
+ * anywhere on it, whatever else its words name ("school").
+ */ export function aiStockAdultsOnly(texts) {
+    const said = texts.filter(Boolean).join(' . ');
+    return ADULT_AUDIENCE.test(said) && !YOUNG_AUDIENCE.test(said);
+}
+/** Where a picture of a moment is set, by the words that name it, and the word a search and a photo say it with. */ const SCENE_SETTINGS = [
+    {
+        words: [
+            'mountain',
+            'mountains',
+            'ridgetop',
+            'ridge',
+            'summit',
+            'peak',
+            'alpine',
+            'overlook',
+            'parkway'
+        ],
+        said: 'mountains'
+    },
+    {
+        words: [
+            'fall',
+            'autumn',
+            'foliage'
+        ],
+        said: 'autumn'
+    },
+    {
+        words: [
+            'winter',
+            'snow',
+            'snowy'
+        ],
+        said: 'winter'
+    },
+    {
+        words: [
+            'beach',
+            'coast',
+            'seaside',
+            'shore',
+            'ocean'
+        ],
+        said: 'beach'
+    },
+    {
+        words: [
+            'forest',
+            'woods',
+            'woodland'
+        ],
+        said: 'forest'
+    },
+    {
+        words: [
+            'spring',
+            'blossom',
+            'blossoms'
+        ],
+        said: 'spring'
+    },
+    {
+        words: [
+            'city',
+            'urban',
+            'downtown'
+        ],
+        said: 'city'
+    }
+];
+/**
+ * The scene a picture's words name (AGL-3856): the people at a moment, and
+ * where — "Ridgetop Elopement" a couple in the mountains, "Mountain Wedding
+ * Day" a wedding couple in the mountains, "Family Session in the Fall" a
+ * family in autumn — read from every word, never only the first clause.
+ * `null` where it names no people.
+ */ export function aiStockScene(text) {
+    const named = sceneWords(text);
+    const scene = PEOPLE_SCENES.find((entry)=>entry.words.some((word)=>named.has(word)));
+    if (!scene) return null;
+    const setting = aiStockSetting(text);
+    const query = scene.query(named);
+    return {
+        queries: [
+            ...new Set([
+                setting ? `${query} ${setting}` : '',
+                query
+            ].filter(Boolean))
+        ],
+        subject: [
+            scene.subject,
+            setting
+        ].filter(Boolean).join(' '),
+        object: scene.subject,
+        lead: scene.lead.map((phrase)=>stemList(phrase).join(' ')),
+        people: scene.people.map(aiStockStem),
+        shun: scene.shun.filter((word)=>!named.has(word)).map(aiStockStem),
+        named: [
+            ...new Set(stemList(text))
+        ]
+    };
+}
+/** A text's lowercase words, letters only. */ const sceneWords = (text)=>new Set(text.toLowerCase().split(/[^a-zÀ-ɏ]+/).filter(Boolean));
+/** Where a text's words set a picture ({@link SCENE_SETTINGS}): "mountains" of "Couples planning mountain weddings"; empty for none. */ export function aiStockSetting(text) {
+    var _ref;
+    var _SCENE_SETTINGS_find;
+    const named = sceneWords(text);
+    return (_ref = (_SCENE_SETTINGS_find = SCENE_SETTINGS.find((entry)=>entry.words.some((word)=>named.has(word)))) == null ? void 0 : _SCENE_SETTINGS_find.said) != null ? _ref : '';
+}
+/**
+ * The moment a portfolio's record shows (AGL-3856): read from the record's
+ * own name first, then from what it is filed under, then as a portrait, and
+ * set where its name, its category or else the site's own words say. A
+ * photographer's "Getting Ready" filed under "Weddings and elopements" is a
+ * wedding couple in the mountains; "Milestone Portraits" filed under "Family
+ * portraits" a family. Its searches end on the people alone ("couple"), so a
+ * moment no photo shows in its setting still shows its people. `null` where
+ * neither names people at a moment nor a portrait.
+ */ export function aiStockRecordScene(name, category = '', siteSetting = '') {
+    var _texts_find, _PEOPLE_SCENES_find, _texts_map_find;
+    const texts = [
+        name,
+        category
+    ].filter((text)=>text.trim());
+    const source = (_texts_find = texts.find((text)=>PEOPLE_SCENES.some((entry)=>entry.words.some((word)=>sceneWords(text).has(word))))) != null ? _texts_find : texts.find((text)=>PORTRAIT_SCENE.words.some((word)=>sceneWords(text).has(word)));
+    if (!source) return null;
+    const named = sceneWords(source);
+    const scene = (_PEOPLE_SCENES_find = PEOPLE_SCENES.find((entry)=>entry.words.some((word)=>named.has(word)))) != null ? _PEOPLE_SCENES_find : PORTRAIT_SCENE;
+    const setting = (_texts_map_find = texts.map(aiStockSetting).find(Boolean)) != null ? _texts_map_find : siteSetting;
+    const query = scene.query(named);
+    const all = sceneWords(texts.join(' '));
+    return {
+        queries: [
+            ...new Set([
+                setting ? `${query} ${setting}` : '',
+                query,
+                scene.subject
+            ].filter(Boolean))
+        ],
+        subject: [
+            scene.subject,
+            setting
+        ].filter(Boolean).join(' '),
+        object: scene.subject,
+        // A record's cover leads with its people: a wedding's table decor is not "Overlook Ceremonies".
+        lead: scene.lead.filter((phrase)=>!RECORD_SCENE_UNPEOPLED.has(phrase)).map((phrase)=>stemList(phrase).join(' ')),
+        people: scene.people.map(aiStockStem),
+        shun: scene.shun.filter((word)=>!all.has(word)).map(aiStockStem),
+        named: [
+            ...new Set(stemList(texts.join(' ')))
+        ]
+    };
+}
+/**
+ * A scene's lead words a record's cover never leads with alone
+ * ({@link aiStockRecordScene}): the moment with no one in it (a wedding's table
+ * decor for "Overlook Ceremonies"), or children with no family (a ski class
+ * for "Milestone Portraits").
+ */ const RECORD_SCENE_UNPEOPLED = words('wedding elopement child children kid kids baby toddler');
+/**
+ * What a portfolio's record is never OF, among its first tags, unless its own
+ * words name it (AGL-3856): an animal, a toy or a figurine. The beta.265
+ * Laurel Ridge "Gallery collections" covers were a toy frog with a camera, a
+ * toy duck and a cat's portrait.
+ */ const RECORD_ODD_LEADS = words('animal animals cat cats kitten dog dogs puppy pet pets bird birds frog frogs duck ducks horse horses cow rabbit bunny ' + 'toy toys figurine figurines lego doll dolls teddy puppet miniature');
 /** An object's kin phrases as stems, or none. */ const kinStems = (entry)=>entry ? [
         ...new Set(entry.kin.map((phrase)=>stemList(phrase).join(' ')))
     ] : [];
@@ -1708,8 +2349,14 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     }
     return searches;
 }
-/** The searches a slot tries, in order, most specific first, each distinct. */ export function aiStockSearchesFor(slot, terms, subject, part) {
-    var _terms_core, _terms_making;
+/**
+ * The searches a slot tries, in order, most specific first, each distinct.
+ * A portrait of one of the business's people ({@link AiLayoutPictureSlot.people})
+ * 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, _ref2, _terms_maker, _ref3;
+    var _aiStockPeopleRole, _slot_record, _slot_record1;
     const orientation = aiStockOrientation(slot.aspect);
     const size = slot.role === 'hero' ? {
         minWidth: 1600
@@ -1719,6 +2366,11 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         minWidth: 900
     };
     const domain = new Set(terms.domain);
+    // A portfolio's record of a craft whose work is people at a moment shows the
+    // moment, never the maker: the beta.265 Laurel Ridge "Gallery collections"
+    // searched "photographer mountain elopements" and placed a press
+    // photographer, a toy frog with a camera and a cat (AGL-3856).
+    const work = aiStockShowsTheWork(slot, terms);
     const object = aiStockObjectWord(subject);
     const subjectStems = stemList(subject);
     const kin = object ? objectKin(object, [
@@ -1738,21 +2390,28 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     // A collection tile is product-like: held to the shop's category and its
     // own object among the first tags, and searched by its object's kin, never
     // the category's world alone (AGL-3660).
-    const collection = part === 'collection' && Boolean(terms.craft);
-    const broad = kin && collection ? [] : terms.broad.map((query)=>({
+    const collection = part === 'collection' && Boolean(terms.craft) && !work;
+    const broad = kin && collection || work ? [] : terms.broad.map((query)=>({
             query,
             broad: true,
             category: collection
         }));
     // The maker at work, held to the craft: never "hands" (AGL-3660).
-    const making = ((_terms_making = terms.making) != null ? _terms_making : []).map((query)=>({
+    const making = (work ? [] : (_terms_making = terms.making) != null ? _terms_making : []).map((query)=>({
             query,
             broad: true,
             category: true
         }));
+    // A portrait in its role, in the site's world, where the libraries know a word for it.
+    const roleWord = slot.people ? (_ref = (_aiStockPeopleRole = aiStockPeopleRole(slot.alt, sectionName)) == null ? void 0 : _aiStockPeopleRole.query) != null ? _ref : '' : '';
+    const role = roleWord ? stemList(terms.business).includes(roleWord) ? terms.business : `${roleWord} ${terms.business}`.trim() : '';
+    // A scene's people are read from every word of the picture's, never its first clause alone.
+    const scene = work ? aiStockRecordScene(slot.alt, (_ref1 = (_slot_record = slot.record) == null ? void 0 : _slot_record.category) != null ? _ref1 : '', (_terms_setting = terms.setting) != null ? _terms_setting : '') : terms.scenes && slot.role !== 'hero' && part !== 'collection' ? aiStockScene(slot.alt) : null;
+    // 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 ? [
         {
-            query: qualify(subject),
+            query: own(subject),
             held: true
         },
         ...kin ? kin.queries.map((query)=>({
@@ -1760,11 +2419,21 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
                 held: true
             })) : [
             {
-                query: qualify(object),
+                query: own(object),
                 held: true
             }
         ]
     ] : [];
+    // 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 ? [
+        ...new Set([
+            ...(_terms_maker = terms.maker) != null ? _terms_maker : [],
+            ...[
+                ...RECORD_ODD_LEADS
+            ].map(aiStockStem)
+        ])
+    ].filter((stem)=>!recordNamed.has(stem)) : [];
     const queries = slot.role === 'hero' ? [
         {
             query: terms.business,
@@ -1772,6 +2441,13 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         },
         ...broad
     ] : slot.role === 'about' ? [
+        ...role ? [
+            {
+                query: role,
+                broad: true,
+                people: true
+            }
+        ] : [],
         ...part === 'story' ? making : [],
         {
             query: `${terms.business} ${subject}`,
@@ -1787,11 +2463,35 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
         ...broad
     ] : [
         ...part === 'story' ? making : [],
-        ...thing,
+        ...scene ? [] : thing,
         ...broad
     ];
     const seen = new Set();
     const searches = [];
+    // A picture of people at a moment asks for them, and where, before anything
+    // else, and takes only a photo leading with them (AGL-3856): never the
+    // roses of a "Mountain Wedding Day", nor a bride for a family session.
+    for (const query of (_ref3 = scene == null ? void 0 : scene.queries) != null ? _ref3 : []){
+        seen.add(`${query}|false`);
+        searches.push(_extends({
+            query,
+            orientation
+        }, size, {
+            strict: true,
+            subject: scene.subject,
+            object: scene.object,
+            kin: scene.lead,
+            lead: true,
+            needs: scene.people,
+            allow: scene.named
+        }, scene.shun.length ? {
+            refuse: scene.shun
+        } : {}, refuseLead.length ? {
+            refuseLead
+        } : {}, work ? {
+            worldless: true
+        } : {}));
+    }
     for (const raw of queries){
         const query = clip(raw.query);
         const key = `${query}|${raw.people === true}`;
@@ -1820,10 +2520,23 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
             category: core
         } : {}, slot.role === 'hero' ? {
             first: true
+        } : {}, refuseLead.length ? {
+            refuseLead
+        } : {}, work ? {
+            worldless: true
         } : {}));
     }
     return searches;
 }
+/**
+ * Whether a slot is a portfolio's record of a craft whose work is people at a
+ * moment (AGL-3856): a photographer's "Mountain Elopements" shows an
+ * elopement, never the photographer. Searched by the moment its words and its
+ * category name, held to no world of the craft, and never led by the craft's
+ * own words, an animal or a toy unless the record names them.
+ */ export function aiStockShowsTheWork(slot, terms) {
+    return Boolean(slot.record) && Boolean(terms.scenes) && slot.role !== 'hero' && !slot.people && !slot.product;
+}
 /** The words of a photo's page address at its library, its id dropped: "robin-bird-songbird-garden-winter". */ function pageSlug(pageUrl) {
     try {
         var _ref;
@@ -1896,7 +2609,8 @@ 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_shunLead, _judgement_leadAny, _judgement_kin, _judgement_requires, _judgement_category, _judgement_object, _judgement_domain;
+    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;
     const hit = hitWords(photo);
     if (hit.rejected) return 0;
     if (aiStockSensitive(photo, judgement.named)) return 0;
@@ -1910,6 +2624,23 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     ]);
     // A dispenser is not a soapmaker's, nor a pump a bar's (AGL-3660).
     if (((_judgement_shun = judgement.shun) != null ? _judgement_shun : []).some((word)=>hit.all.has(word) && !owned.has(word))) return 0;
+    // A family session is never a bride, however the photographer's brief names weddings.
+    if (((_judgement_refuse = judgement.refuse) != null ? _judgement_refuse : []).some((word)=>hit.all.has(word))) return 0;
+    // A teacher's portrait is never OF a child, whatever else it names.
+    if (((_judgement_refuseLead = judgement.refuseLead) != null ? _judgement_refuseLead : []).some((word)=>hit.lead.has(word))) return 0;
+    // 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 _judgement_roleScene1;
+        const first = new Set(stemList(((_photo_tags = photo.tags) != null ? _photo_tags : []).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(' ')));
+        if (((_judgement_roleRefuse1 = judgement.roleRefuse) != null ? _judgement_roleRefuse1 : []).some((stem)=>read.has(stem))) return 0;
+    }
+    // A wedding day shows its people: a close-up of roses tagged "wedding" never fills it.
+    const needs = (_judgement_needs = judgement.needs) != null ? _judgement_needs : [];
+    if (needs.length && !needs.some((word)=>hit.all.has(word))) return 0;
     // What the photo is OF: a typewriter's terms of service are not a law firm's.
     if (((_judgement_shunLead = judgement.shunLead) != null ? _judgement_shunLead : []).some((word)=>hit.lead.has(word) && !owned.has(word))) return 0;
     if (judgement.product) {
@@ -1988,6 +2719,10 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     if (phrased) score += 3;
     for (const word of new Set(subject))if (word !== object && hit.all.has(word)) score += 1;
     if (world) score += worldLead ? 1.25 : 1;
+    // A portrait in its role: a teacher at the board over a woman in a classroom.
+    const roles = (_judgement_roles = judgement.roles) != null ? _judgement_roles : [];
+    if (roles.some((word)=>hit.lead.has(word))) score += 4;
+    else if (roles.some((word)=>hit.all.has(word))) score += 2;
     // A hero is most of all what its first tags say: "law office, lawyer,
     // 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.
@@ -2022,6 +2757,36 @@ const clip = (query)=>query.replace(/\s+/g, ' ').trim().slice(0, STOCK_PHOTO_QUE
     }
     return ranked;
 }
+/**
+ * Whether two hits are of one shoot (AGL-3856): one contributor's photos a few
+ * uploads apart, as Pixabay numbers them — the beta.265 Granite Peak Barbell
+ * coaches were four of one model, 728223 to 728229 — else one page address.
+ */ export function aiStockSameShoot(a, b) {
+    const near = Number(a.id) && Number(b.id) ? Math.abs(Number(a.id) - Number(b.id)) < 100 : false;
+    if (a.photographer && a.photographer === b.photographer && near) return true;
+    const slug = pageSlug(a.pageUrl);
+    return Boolean(slug) && slug === pageSlug(b.pageUrl);
+}
+/**
+ * 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) {
+    if (!shown.length || ranked.length < 2) return [
+        ...ranked
+    ];
+    const best = aiStockRelevance(ranked[0], judgement);
+    const top = 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
+    ];
+    return [
+        ...fresh,
+        ...ranked.filter((photo)=>!fresh.includes(photo))
+    ];
+}
 /** The pick among a search's hits: the first {@link aiStockRank} would try, or `null`. */ export function aiStockPick(photos, used, seed, judgement = {}) {
     var _aiStockRank_;
     return (_aiStockRank_ = aiStockRank(photos, used, seed, judgement)[0]) != null ? _aiStockRank_ : null;
@@ -2068,61 +2833,284 @@ function jobPhotos(key) {
 /** The longest description of a photo written from the library's own words. */ const AI_STOCK_ALT_MAX = 160;
 /**
  * Words a tag uses for how a photo looks or feels, never a thing it shows
- * (AGL-3856): "extravagant" of "wedding dress, bride, extravagant".
- */ const DESCRIBING = words('love romance romantic luxury luxurious fancy extravagant happiness happy beauty emotion emotions mood lifestyle ' + 'concept aesthetic wallpaper background retro vintage antique old young cute sexy fun funny sad positive healthy fit ' + 'strong powerful homemade tasty yummy sweet sweetness nice dark bw monochrome macro sporty active married bridal ' + 'female male');
-/** What a tag names that takes no article: "law" of "hammer, books, law". */ const MASS_NOUNS = words('food coffee tea bread wood water law fitness wax soap clay nature money fabric yarn wool furniture jewelry jewellery ' + 'pottery glass paper music art sport health business meat grass snow sand gold silver leather cotton hair makeup ' + 'skincare justice equipment technology work architecture decor fashion wildlife marriage photography exercise ' + 'scenery weather traffic education advocacy wine beer chocolate rice sugar flour milk cheese honey oil ice fire ' + 'light sunlight dough sourdough pastry dessert strength crossfit people');
-/** 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');
+ * (AGL-3856): "extravagant" of "wedding dress, bride, extravagant", "moody"
+ * of "forest, human, photographer", a season or a people's name.
+ */ const DESCRIBING = words('love romance romantic luxury luxurious fancy extravagant happiness happy beauty emotion emotions mood lifestyle ' + 'concept aesthetic wallpaper background retro vintage antique old young cute sexy fun funny sad positive negative healthy fit ' + 'strong powerful homemade tasty yummy sweet sweetness nice dark bw monochrome macro sporty active married bridal ' + 'female male adult good bad poc bipoc moody sunny rainy foggy misty snowy cloudy stormy dreamy shiny trendy messy ' + 'casual blonde blond brunette muscular athletic clever intelligent concentrated curious lonely sleepy heavy ' + 'nature outdoors outdoor indoors indoor scenery scenic autumn fall winter spring summer ' + 'physical teenage traveling ' + // Adjectives a tag gives alone, never a thing: "students, multicultural" (AGL-3856).
+'multicultural multiethnic multiracial diverse international cultural traditional modern classic classical ' + 'domestic wild tropical rural urban ' + // How the photo was made, never what it shows: "cutout, perspective", "men, silhouettes".
+'silhouette silhouettes cutout perspective bokeh closeup ' + // A holiday names when, never a thing: "tet market" is a market.
+'tet christmas easter halloween diwali ramadan hanukkah thanksgiving ' + 'indian asian african american european caucasian vietnamese japanese chinese korean thai latino latina hispanic ' + 'japan vietnam viet nam thailand india china korea germany france italy spain england britain uk usa america ' + 'canada mexico brazil australia africa europe asia');
+/**
+ * Words a tag uses for what a person or a thing is like, said before it
+ * rather than as a thing of its own (AGL-3856): "a confident lawyer", "an
+ * elderly couple", "an analog camera", never "a lawyer, law and a confident".
+ */ const QUALITIES = words('confident professional successful serious smart busy creative proud skilled experienced determined focused ' + 'senior junior expert friendly cheerful smiling elderly analog analogue digital mirrorless');
+/** What a tag names that takes no article: "chalk" of "board, chalk". */ const MASS_NOUNS = words('food coffee tea bread wood water wax soap clay money fabric yarn wool furniture jewelry jewellery ' + 'pottery glass paper music art hair makeup chalk paint ink dust stone marble concrete steel metal ' + 'skincare equipment decor fashion wildlife weather traffic wine beer chocolate rice sugar flour milk ' + 'cheese honey oil ice fire light sunlight dough sourdough pastry dessert people foliage greenery faculty staff ' + 'clothing bedding frosting icing flooring');
+/** Nouns plural without an "-s": said without an article, "women in a classroom". */ const PLURAL_NOUNS = words('men women people children feet teeth mice geese sheep fish');
+/**
+ * What a tag names that no photo shows as a thing of its own (AGL-3856): an
+ * idea ("law" of "lawyer, law", "feedback" of "board, chalk, feedback"), a
+ * doing ("read", "lift", "fitness", "a workout"), a word for the photo itself
+ * ("photo", "spot"). Left out, never said with an article: "A bookwork and a
+ * read", "A kettlebell and fitness", "A board and training" said nothing.
+ */ const ABSTRACT_NOUNS = words('law justice advocacy business feedback review news return communication communicate discussion dialog conversation ' + 'success career work job satisfaction quality concept idea strategy marketing education technology health support ' + 'confirmation opinion rating evaluation planning project presentation optimization information internet finance ' + 'management leadership teamwork motivation growth strength service services help advice consulting consultation ' + 'marriage photography architecture travel transport transportation industry company corporate social e-business ' + 'fitness workout workouts exercise exercises crossfit sport sports skill skills knowledge exam exams lecture ' + 'session lesson course hobby leisure power energy wellness talent formation participation ' + 'press show day days night year years time holiday month months week weeks morning evening afternoon ' + 'kiss hug embrace ' + 'photo photos picture pictures image images shot shots shoot shoots spot spots ' + 'read write learn study lift move remove focus relax think sit smile laugh eat swim teach enjoy celebrate explore ' + 'hike can');
+/** Words ending as an idea does that are things: "a station", "a city", "a ship". */ const CONCRETE_ABSTRACT_ENDINGS = words('station mansion lotion potion ornament instrument apartment monument pavement basement garment compartment ' + 'equipment cement city university facility ship warship spaceship airship');
+/** Whether a word is an idea or a doing by how it ends: "participation", "unity", "empowerment". */ const saysAnIdea = (word)=>/(?:tion|sion|ment|ness|ity|ship|ism)s?$/.test(word) && !CONCRETE_ABSTRACT_ENDINGS.has(aiStockStem(word));
+/**
+ * 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');
+/** 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');
+/** People a photo shows; the generic ones give way to a role ("man" to "businessman"). */ const PEOPLE_NOUNS = words('man men woman women person people human humans boy boys girl girls guy guys lady ladies child children kid kids ' + 'baby family couple bride groom schoolgirl schoolboy teen teenager student students graduate athlete athletes ' + 'businessman businesswoman businessmen lawyer attorney doctor dentist nurse chef cook baker barista ' + 'trainer coach teacher teachers instructor lecturer professor tutor worker workers entrepreneur model ' + 'photographer potter artist florist mother father parent parents grandmother grandfather grandparents ' + 'faculty staff team participants volunteer volunteers musician dancer leader manager owner founder ' + 'journalist journalists reporter reporters master masters lovers newlywed newlyweds husband wife fiance fiancee spouse');
+/** People said by no role: a model is whoever posed (AGL-3856), "a woman" of "woman, model, show, teacher". */ const GENERIC_PEOPLE = words('man men woman women person people human humans guy guys lady ladies adult boy boys girl girls model models');
+/**
+ * A body's parts, never a thing a photo is described by (AGL-3856): "A girl
+ * with a hand" said nothing, and "A body in a gym" is a gym.
+ */ const BODY_PARTS = words('hand hands finger fingers arm arms leg legs foot feet body bodies face faces eye eyes skin head heads lip lips mouth nose ' + 'ear ears neck shoulder shoulders knee knees');
+/**
+ * Words for a kind of thing, said only where nothing names the thing itself
+ * (AGL-3856): "A domestic cat and an animal" is a cat.
+ */ const KINDS_OF_THING = words('animal animals pet pets creature creatures mammal mammals object objects thing things item items');
+/** How many of a photo's first tags a person leads its description from, where it names a thing too: "A camera" of "petri, camera, film, photography, photographer" (AGL-3856). */ const ALT_PERSON_TAGS_READ = 4;
+/** How many of a photo's first tags a role is said from, over a man or a woman before it: "A man" of "bed, book, man, …, student" (AGL-3856). */ const ALT_ROLE_TAGS_READ = 6;
+/** What a person in a photo wears, said "in": "a bride in a wedding dress". */ const CLOTHING = words('dress gown suit uniform costume coat jacket robe apron');
+/**
+ * Places a photo is set in, each with how a phrase says it is there: "a
+ * train at a station", "a lawyer in court", "a couple at a wedding".
+ */ const PLACES = {
+    station: 'at',
+    market: 'at',
+    desk: 'at',
+    table: 'at',
+    counter: 'at',
+    school: 'at',
+    college: 'at',
+    university: 'at',
+    wedding: 'at',
+    sunset: 'at',
+    sunrise: 'at',
+    dusk: 'at',
+    dawn: 'at',
+    beach: 'on',
+    bed: 'on',
+    sofa: 'on',
+    couch: 'on',
+    bench: 'on',
+    trail: 'on',
+    path: 'on',
+    bridge: 'on',
+    street: 'on',
+    court: 'in',
+    courtroom: 'in',
+    office: 'in',
+    kitchen: 'in',
+    gym: 'in',
+    studio: 'in',
+    classroom: 'in',
+    class: 'in',
+    hall: 'in',
+    room: 'in',
+    garden: 'in',
+    park: 'in',
+    shop: 'in',
+    store: 'in',
+    bakery: 'in',
+    cafe: 'in',
+    restaurant: 'in',
+    workshop: 'in',
+    library: 'in',
+    salon: 'in',
+    clinic: 'in',
+    forest: 'in',
+    city: 'in',
+    church: 'in',
+    field: 'in',
+    meadow: 'in',
+    valley: 'in',
+    mountain: 'in',
+    hill: 'on',
+    cliff: 'on',
+    river: 'by',
+    lake: 'by',
+    waterfall: 'at'
+};
+/** Places that are things too, a photo's subject where nothing else is: "a desk in a classroom". */ const OBJECT_PLACES = words('desk table counter bridge bed sofa couch bench');
+/** Places said without an article: "in court", "at sunset". */ const BARE_PLACES = words('court sunset sunrise dusk dawn');
+/** Places said in words of their own: a mountain tag is "in the mountains". */ const PLACES_SAID = {
+    mountain: 'the mountains'
+};
+/** How many of a photo's first tags its description reads: the things and people it is OF. */ const ALT_TAGS_READ = 8;
+/** How far a photo's tags are read for where it is set, said last: "in a gym" of a kettlebell's seventh tag. */ const ALT_PLACE_TAGS_READ = 10;
+/** A tag's words, a word for the photo itself taken off a compound: "photo-camera" is a camera. */ function tagWords(tag) {
+    return tag.toLowerCase().replace(/[^a-zÀ-ɏ\s'-]/g, ' ').replace(/\b(?:photo|picture|image)-(?=[a-z])/g, '').split(/\s+/).filter(Boolean);
+}
 /**
  * A tag as a phrase of an English description (AGL-3856): "a wedding dress",
- * "an attorney", "books", "law", "Columbus"; `null` for a tag that names no
- * thing ("extravagant", "beautiful") or is too long to be one.
+ * "an attorney", "books", "chalk", "Columbus"; `null` for a tag that names no
+ * thing ("extravagant", "feedback", "training", "sony") or is too long to be
+ * one.
  */ function describedTag(tag, proper) {
-    const describing = (word)=>FILLER.has(word) || DESCRIBING.has(word) || /(?:ous|ful)$/.test(word) || word.length > 4 && /[^e]ed$/.test(word);
-    const all = tag.toLowerCase().replace(/[^a-zÀ-ɏ\s'-]/g, ' ').split(/\s+/).filter(Boolean);
-    // "Beautiful flowers" shows flowers; "roasted" shows nothing.
-    const list = all.filter((word)=>!describing(word));
+    const describing = (word)=>FILLER.has(word) || DESCRIBING.has(word) || QUALITIES.has(word) || /(?:ous|ful)$/.test(word) || word.length > 4 && /[^e]ed$/.test(word);
+    const all = tagWords(tag);
+    // "Beautiful flowers" shows flowers; "roasted" shows nothing; "photo model"
+    // is a model and "traveling couples" are couples: a word before the last
+    // that is a doing says what they do, never what they are.
+    const list = all.filter((word, index)=>!describing(word) && !(all.length > 1 && /^(?:photo|picture|image)$/.test(word)) && !(index < all.length - 1 && index > 0 && word.endsWith('ing') && !COUNTED_ING.has(word)));
     if (!list.length || all.length > 3) return null;
     // A phrase of no thing ("up close") or a doing ("take pictures", "to lift", "work out") is not what it shows.
-    if (list.every((word)=>STOPWORDS.has(word) && word !== 'people' && word !== 'person')) return null;
-    if (/^(?:to|take|taking|make|making|get|do|go|lie)$/.test(list[0])) return null;
+    if (list.every((word)=>STOPWORDS.has(word) && !SAID_PEOPLE.has(word))) return null;
+    if (/^(?:to|take|taking|make|making|get|do|go|lie|in|on|at|for|with|by|of)$/.test(list[0])) return null;
     if (/^(?:out|up|off|down|away|on|in)$/.test(list[list.length - 1])) return null;
+    if (list.some((word)=>BRANDS.has(word))) return null;
     if (list.every((word)=>proper.has(word))) return list.map((word)=>`${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(' ');
-    const phrase = list.join(' ');
     const last = list[list.length - 1];
-    const plural = aiStockStem(last) !== last && !/^(?:lens|canvas|atlas|gas|bus)$/.test(last);
-    const uncounted = MASS_NOUNS.has(last) || last.endsWith('ing') && !COUNTED_ING.has(last);
-    if (plural || uncounted || STOPWORDS.has(list[0]) && list[0] !== 'person') return phrase;
-    return `${/^(?:[aeio]|u(?!ni|s[eu]))/.test(phrase) ? 'an' : 'a'} ${phrase}`;
+    // An idea or a doing, never a thing: "law", "feedback", "customer satisfaction", "participation", "weightlifting".
+    if (ABSTRACT_NOUNS.has(last) || ABSTRACT_NOUNS.has(aiStockStem(last)) || saysAnIdea(last)) return null;
+    const doing = last.endsWith('ing') && !COUNTED_ING.has(aiStockStem(last)) && !UNCOUNTED_ING.has(last);
+    if (doing) return null;
+    const phrase = list.join(' ');
+    const plural = PLURAL_NOUNS.has(last) || aiStockStem(last) !== last && !/^(?:lens|canvas|atlas|gas|bus)$/.test(last);
+    if (plural || MASS_NOUNS.has(last) || STOPWORDS.has(list[0]) && !SAID_PEOPLE.has(list[0])) return phrase;
+    return `${articleFor(phrase)} ${phrase}`;
+}
+/** "a" or "an" before a phrase. */ const articleFor = (phrase)=>/^(?:[aeio]|u(?!ni|s[eu]))/.test(phrase) ? 'an' : 'a';
+/** Whether two words name one thing, one inside the other: "law" and "lawyer", "cam" and "camera". */ function nearSynonyms(a, b) {
+    const [short, long] = a.length <= b.length ? [
+        a,
+        b
+    ] : [
+        b,
+        a
+    ];
+    return short.length >= 3 && short !== long && (long.startsWith(short) || long.endsWith(short));
 }
 /**
- * A photo described from its own tags (AGL-3856): its first few that name a
- * thing, a phrase another one holds dropped ("wedding" beside "wedding
- * dress"), as an English phrase — "A wedding dress and a bride", "A hammer,
- * books and law" — never the comma-separated list the library keeps. `null`
- * where none names a thing.
+ * A photo described from its own tags (AGL-3856): a short English phrase of
+ * concrete things, never the library's comma-separated list: "A train at a
+ * station", "A confident lawyer in court", "A portrait of a businessman", "A
+ * photographer with a camera on a beach", "A kettlebell in a gym", "An analog
+ * camera". It says one person at most (a role over a man or a woman, an adult
+ * over a girl), what they hold or wear, or one or two things, and where:
+ *
+ * - an idea or a doing ("law", "feedback", "training", "a read",
+ *   "participation"), a maker's name ("sony"), a word for the photo itself
+ *   ("photo", "spot") and a look ("moody", "analog" alone, a season) are left
+ *   out; a quality ("elderly", "analog") is said before the one thing it
+ *   qualifies;
+ * - of two words for one thing the first tag's stays ("book" over
+ *   "bookwork", "camera" over "photo-camera"), unless the later phrase holds
+ *   it whole ("wedding dress" over "wedding");
+ * - a second thing comes only from the first two tags and where no place is
+ *   said, what a person holds only from the first three, where it is set
+ *   from the first ten;
+ * - no word is said twice: never "an elderly couple and an elderly".
+ *
+ * `null` where no tag names a thing.
  */ export function aiStockTagsAlt(tags, proper = new Set()) {
-    const kept = [];
-    for (const tag of tags.slice(0, 6)){
-        if (kept.length >= 3) break;
+    const parts = [];
+    let quality = '';
+    let portrait = false;
+    for (const [index, tag] of tags.slice(0, ALT_PLACE_TAGS_READ).entries()){
+        var _ref;
+        var _bare_split_pop;
+        const lower = tag.toLowerCase().trim();
+        const reading = index < ALT_TAGS_READ;
+        if (reading && (lower === 'portrait' || lower === 'portraits')) {
+            portrait = true;
+            continue;
+        }
+        if (QUALITIES.has(lower)) {
+            if (reading) quality || (quality = lower);
+            continue;
+        }
         const said = describedTag(tag, proper);
         if (!said) continue;
-        const stems = stemList(said.replace(/^an?\s+/, ''));
-        if (kept.some((entry)=>stems.every((stem)=>entry.stems.includes(stem)))) continue;
-        // A longer phrase takes the place of one it holds: "wedding dress" for "wedding".
-        const within = kept.findIndex((entry)=>entry.stems.every((stem)=>stems.includes(stem)));
-        if (within >= 0) kept.splice(within, 1, {
+        const bare = said.replace(/^an?\s+/, '');
+        const stems = stemList(bare);
+        const head = (_ref = (_bare_split_pop = bare.split(/\s+/).pop()) == null ? void 0 : _bare_split_pop.toLowerCase()) != null ? _ref : '';
+        if (!head) continue;
+        const headStem = aiStockStem(head);
+        const kind = PEOPLE_NOUNS.has(head) || PEOPLE_NOUNS.has(headStem) ? 'person' : PLACES[headStem] ? 'place' : 'thing';
+        // Past the first tags only where it is set is read.
+        if (!reading && kind !== 'place') continue;
+        // A hand or a body is never what a photo is described by.
+        if (kind === 'thing' && (BODY_PARTS.has(head) || BODY_PARTS.has(headStem))) continue;
+        if (parts.some((part)=>stems.every((stem)=>part.stems.includes(stem)))) continue;
+        const part = {
+            said,
             stems,
-            said
-        });
-        else kept.push({
-            stems,
-            said
-        });
+            head: headStem,
+            kind,
+            index
+        };
+        // A longer phrase of the same thing takes its place: "elderly couple" for "couple".
+        const holds = parts.findIndex((held)=>held.head === headStem && held.stems.every((stem)=>stems.includes(stem)));
+        if (holds >= 0) {
+            parts.splice(holds, 1, _extends({}, part, {
+                index: parts[holds].index
+            }));
+            continue;
+        }
+        // Two words for one thing ("book" and "bookwork", "cam" and "camera"): the
+        // first tag's stays; a person's are told apart by their role below.
+        if (kind !== 'person' && parts.some((held)=>held.kind !== 'person' && nearSynonyms(held.head, headStem))) continue;
+        parts.push(part);
+    }
+    // One person: a role among the first tags over a man, a woman, a girl
+    // ("businessman" over "man"), else the first; a role tagged later is not
+    // what the photo shows ("bed, book, man, …, student" is a man), nor is one
+    // a model posed as ("woman, model, show, teacher" is a woman).
+    const people = parts.filter((part)=>part.kind === 'person');
+    const posed = people.some((part)=>part.head === 'model');
+    let places = parts.filter((part)=>part.kind === 'place');
+    let things = parts.filter((part)=>part.kind === 'thing');
+    // A kind of thing only where nothing names the thing: "a cat", never "a cat and an animal".
+    if (things.some((part)=>!KINDS_OF_THING.has(part.head))) things = things.filter((part)=>!KINDS_OF_THING.has(part.head));
+    // A person tagged after the things a photo is of is not who it shows:
+    // "petri, camera, film, photography, photographer" is a camera, and "men,
+    // silhouettes, camera, nature, photographer" men with a camera.
+    const leads = (part)=>portrait || part.index < ALT_PERSON_TAGS_READ || !things.length;
+    const role = posed ? undefined : people.find((part)=>!GENERIC_PEOPLE.has(part.head) && part.index < ALT_ROLE_TAGS_READ && leads(part));
+    const person = role != null ? role : people.find(leads);
+    // Nothing but places: a desk is the thing in a classroom; "a school in a classroom" says one place.
+    if (!person && !things.length && places.length > 1) {
+        const object = places.find((part)=>OBJECT_PLACES.has(part.head));
+        if (object) {
+            things = [
+                object
+            ];
+            places = places.filter((part)=>part !== object);
+        } else places = places.slice(0, 1);
+    }
+    const place = places[0];
+    if (!person && !things.length && !place) return null;
+    /** Every word said so far, so none is said twice. */ const said = new Set();
+    const fresh = (part)=>{
+        const list = stemList(part.said.replace(/^an?\s+/, ''));
+        if (list.some((stem)=>said.has(stem))) return false;
+        for (const stem of list)said.add(stem);
+        return true;
+    };
+    /** A quality before a single counted word: "a confident lawyer", "an analog camera". */ const qualified = (part)=>quality && /^an? \S+$/.test(part.said) && !said.has(aiStockStem(quality)) ? `${articleFor(quality)} ${quality} ${part.said.replace(/^an?\s+/, '')}` : part.said;
+    let phrase = '';
+    if (person && fresh(person)) {
+        phrase = portrait ? `a portrait of ${person.said}` : qualified(person);
+        const held = things.find((part)=>part.index <= 2);
+        if (!portrait && held && fresh(held)) phrase += ` ${CLOTHING.has(held.head) ? 'in' : 'with'} ${held.said}`;
+    } else if (things[0] && fresh(things[0])) {
+        phrase = qualified(things[0]);
+        const second = things[1];
+        if (second && second.index <= 1 && !place && fresh(second)) phrase += ` and ${second.said}`;
+    }
+    if (place && fresh(place)) {
+        var _PLACES_place_head, _PLACES_SAID_place_head;
+        const preposition = (_PLACES_place_head = PLACES[place.head]) != null ? _PLACES_place_head : 'in';
+        const where = (_PLACES_SAID_place_head = PLACES_SAID[place.head]) != null ? _PLACES_SAID_place_head : BARE_PLACES.has(place.head) && /^an? \S+$/.test(place.said) ? place.head : place.said;
+        phrase = phrase ? `${phrase} ${preposition} ${where}` : where;
     }
-    if (!kept.length) return null;
-    const said = kept.map((entry)=>entry.said);
-    const joined = said.length > 1 ? `${said.slice(0, -1).join(', ')} and ${said[said.length - 1]}` : said[0];
-    const out = `${joined.charAt(0).toUpperCase()}${joined.slice(1)}`;
+    if (!phrase) return null;
+    const out = `${phrase.charAt(0).toUpperCase()}${phrase.slice(1)}`;
     return out.length > AI_STOCK_ALT_MAX ? out.slice(0, AI_STOCK_ALT_MAX).replace(/[\s,]+\S*$/, '') : out;
 }
 /** The thing a description names: its subject's object, a trailing "speaking calmly" or "dusted" dropped. */ function describedObject(text, sectionName) {
@@ -2155,12 +3143,13 @@ function jobPhotos(key) {
  * description, and are never kept. Otherwise the photo is described by the
  * library's own words: its description where it writes one (a Pexels hit's
  * `alt`), else its first tags as an English phrase ({@link aiStockTagsAlt}),
- * never the library's tag list. The libraries write in English, and no model
+ * never the library's tag list, and where no tag names a thing, the slot's
+ * own subject: its words, else its section's name. The libraries write in English, and no model
  * translates them, so a site in another language takes the platform's own
  * words for an illustrative photo in its language (`aiLayoutLabel`), true of
  * any photo, as does a hit whose words name no thing.
  */ export function aiStockPhotoAlt(photo, slot, input = {}) {
-    var _photo_alt, _aiStockTagsAlt, _photo_tags;
+    var _photo_alt, _input_sectionName, _aiStockTagsAlt, _photo_tags;
     if (aiLayoutSpeaksOtherThanEnglish(input.language)) return aiLayoutLabel('illustrativePhoto', input.language);
     if (!slot.standIn) {
         var _photo_tags1, _ref;
@@ -2177,7 +3166,13 @@ function jobPhotos(key) {
     }
     const own = ((_photo_alt = photo.alt) != null ? _photo_alt : '').replace(/\s+/g, ' ').trim();
     if (own) return own.length > AI_STOCK_ALT_MAX ? `${own.slice(0, AI_STOCK_ALT_MAX).replace(/\s+\S*$/, '')}…` : own;
-    return (_aiStockTagsAlt = aiStockTagsAlt((_photo_tags = photo.tags) != null ? _photo_tags : [], input.proper)) != null ? _aiStockTagsAlt : aiLayoutLabel('illustrativePhoto', input.language);
+    // No tag names a thing: the slot's own subject, as its words or its section's name say it, never a tag list.
+    const subject = [
+        slot.alt,
+        (_input_sectionName = input.sectionName) != null ? _input_sectionName : ''
+    ].map((text)=>text.replace(/\s+/g, ' ').trim()).find((text)=>/[A-Za-zÀ-ɏ]/.test(text));
+    const fallback = subject ? `${subject.charAt(0).toUpperCase()}${subject.slice(1)}`.slice(0, AI_STOCK_ALT_MAX) : '';
+    return (_aiStockTagsAlt = aiStockTagsAlt((_photo_tags = photo.tags) != null ? _photo_tags : [], input.proper)) != null ? _aiStockTagsAlt : fallback || aiLayoutLabel('illustrativePhoto', input.language);
 }
 /** The names a business type writes with a capital, lowercased: "columbus", "ohio" (AGL-3856). */ export function aiStockProperWords(businessType) {
     const found = new Set();
@@ -2190,19 +3185,33 @@ const EXTENSIONS = {
     'image/webp': 'webp'
 };
 /**
- * A job's language and English photo words (AGL-3760), and the English name
- * of its kind of site (AGL-3771), as a stock photo source takes them.
+ * A job's language and English photo words (AGL-3760), the English name of
+ * its kind of site (AGL-3771), and the business's name and audience as the
+ * person typed them (AGL-3856), as a stock photo source takes them.
  */ export function aiStockPhotoWordsOf(job) {
     const plan = job.plan;
     const kind = job.inputs ? aiSiteKindOfInputs(job.inputs) : null;
     // "Restaurant & café" searches as "restaurant cafe".
     const kindWords = kind ? kind.label.normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/&/g, ' ').replace(/\s+/g, ' ').trim().toLowerCase() : '';
+    const said = (key)=>{
+        var _job_inputs;
+        const value = (_job_inputs = job.inputs) == null ? void 0 : _job_inputs[key];
+        return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+    };
+    const name = said('businessName');
+    const audience = said('audience');
     return _extends({}, (plan == null ? void 0 : plan.language) ? {
         language: plan.language
     } : {}, (plan == null ? void 0 : plan.photoWords) ? {
         photoWords: plan.photoWords
     } : {}, kindWords ? {
         kindWords
+    } : {}, kind ? {
+        kind: kind.id
+    } : {}, name ? {
+        name
+    } : {}, audience ? {
+        audience
     } : {});
 }
 /**
@@ -2229,9 +3238,580 @@ const EXTENSIONS = {
  * its business named in English, else its plan's photo words' subject, else
  * its kind of site), every other site by its business type. One reading for
  * every slot of every source — hero, background, gallery, card, product,
- * post — so no slot searches by words another slot is held against.
+ * post — so no slot searches by words another slot is held against. A site for
+ * adults alone ({@link aiStockAdultsOnly}) is told so, whatever its world.
  */ export function aiStockSourceTerms(input) {
-    return aiStockSiteTerms(aiStockSourceSubject(input) || input.business);
+    var _input_audience;
+    const terms = sourceWorldTerms(input);
+    // Where the site's own words set it: a photographer "in the Blue Ridge" for "mountain weddings" (AGL-3856).
+    const setting = aiStockSetting([
+        input.business,
+        (_input_audience = input.audience) != null ? _input_audience : ''
+    ].join(' . '));
+    return _extends({}, terms, aiStockAdultsOnly([
+        input.audience,
+        input.name,
+        input.business
+    ]) ? {
+        adults: true
+    } : {}, setting ? {
+        setting
+    } : {});
+}
+/** What a source's photos are searched by: its world, as {@link aiStockSourceTerms} reads it. */ function sourceWorldTerms(input) {
+    var _input_name, _input_audience, _input_name1, _input_audience1, _input_kind;
+    const english = aiStockSourceSubject(input);
+    const terms = aiStockSiteTerms(english || input.business);
+    if (english || terms.domain.length && !aiStockIsAbbreviation(input.business)) return terms;
+    // A business type that names no world ("a local service business"), or
+    // one the libraries do not know ("LMS"), is searched by the craft its
+    // name, else its audience, names (AGL-3856): the beta.261 Synchronicity Gym
+    // hero searched nothing at all and was left a black scrim, and its closing
+    // band, held to no world, took a subway train for "Ready to train". Then by
+    // the kind of site its name says ("Adult Hybrid Learning Center"), and
+    // last by the kind of site the person picked: the beta.262 Adult Hybrid
+    // Learning Center searched "lms" and shipped no photo at all.
+    const craft = aiStockListedCraft((_input_name = input.name) != null ? _input_name : '') || aiStockListedCraft((_input_audience = input.audience) != null ? _input_audience : '');
+    const kind = craft ? '' : aiStockNamedKind((_input_name1 = input.name) != null ? _input_name1 : '') || aiStockNamedKind((_input_audience1 = input.audience) != null ? _input_audience1 : '') || ((_input_kind = input.kind) != null ? _input_kind : '');
+    const found = craft ? aiStockSiteTerms(craft) : aiStockKindTerms(kind);
+    if (!found) return terms;
+    return _extends({}, found, {
+        named: [
+            ...new Set([
+                ...terms.named,
+                ...found.named
+            ])
+        ]
+    });
+}
+/**
+ * Whether a business type is only an abbreviation the libraries do not know
+ * (AGL-3856): "LMS", "CRM", "B2B". Its letters are no world to search.
+ */ export function aiStockIsAbbreviation(businessType) {
+    const list = businessType.trim().split(/\s+/).filter(Boolean);
+    return list.length > 0 && list.length <= 2 && list.every((word)=>/^[A-Z0-9&/.-]{2,6}s?$/.test(word) && /[A-Z]/.test(word));
+}
+/**
+ * What a picture of each kind of site the guided start offers shows, where
+ * nothing else says (AGL-3856): the words it is searched by, the words a
+ * photo of it is tagged with, and its broad searches. A kind whose subject
+ * is a craft {@link CRAFT_KIN} lists takes that craft's own.
+ */ const KIND_SUBJECTS = {
+    business: {
+        subject: 'small business',
+        kin: [
+            'business',
+            'office',
+            'team',
+            'meeting',
+            'workplace',
+            'coworkers',
+            'entrepreneur',
+            'shop',
+            'service',
+            'customer'
+        ],
+        broad: [
+            'small business owner',
+            'team meeting office'
+        ]
+    },
+    trades: {
+        subject: 'contractor',
+        kin: [
+            'contractor',
+            'construction',
+            'repair',
+            'renovation',
+            'tools',
+            'worker',
+            'handyman',
+            'plumber',
+            'electrician',
+            'house',
+            'roof'
+        ],
+        broad: [
+            'home repair contractor',
+            'construction worker tools'
+        ]
+    },
+    professional: {
+        subject: 'consultant',
+        kin: [
+            'consultant',
+            'consulting',
+            'office',
+            'meeting',
+            'client',
+            'advisor',
+            'finance',
+            'accountant',
+            'lawyer',
+            'desk',
+            'business'
+        ],
+        broad: [
+            'consultant client meeting',
+            'professional office'
+        ]
+    },
+    wellness: {
+        subject: 'wellness',
+        kin: [
+            'wellness',
+            'health',
+            'therapy',
+            'therapist',
+            'massage',
+            'spa',
+            'relaxation',
+            'clinic',
+            'healthcare'
+        ],
+        broad: [
+            'wellness therapy',
+            'massage therapy'
+        ]
+    },
+    restaurant: {
+        subject: 'restaurant',
+        kin: [
+            'restaurant',
+            'dining',
+            'food',
+            'dish',
+            'chef',
+            'meal',
+            'cafe',
+            'cuisine',
+            'dinner',
+            'lunch'
+        ],
+        broad: [
+            'restaurant dining',
+            'restaurant food'
+        ]
+    },
+    store: {
+        subject: 'boutique',
+        kin: [
+            'boutique',
+            'shop',
+            'store',
+            'shopping',
+            'retail',
+            'products',
+            'display',
+            'shelf'
+        ],
+        broad: [
+            'boutique shop',
+            'retail store display'
+        ]
+    },
+    portfolio: {
+        subject: 'artist',
+        kin: [
+            'art',
+            'artist',
+            'design',
+            'creative',
+            'studio',
+            'workspace',
+            'painting',
+            'drawing'
+        ],
+        broad: [
+            'artist studio',
+            'creative workspace'
+        ]
+    },
+    studio: {
+        subject: 'design studio',
+        kin: [
+            'design',
+            'designer',
+            'studio',
+            'creative',
+            'agency',
+            'team',
+            'workspace',
+            'office'
+        ],
+        broad: [
+            'design studio team',
+            'creative agency office'
+        ]
+    },
+    photography: {
+        subject: 'photographer'
+    },
+    blog: {
+        subject: 'writer',
+        kin: [
+            'writer',
+            'writing',
+            'notebook',
+            'laptop',
+            'desk',
+            'journal',
+            'reading',
+            'book'
+        ],
+        broad: [
+            'writer desk laptop',
+            'writing notebook'
+        ]
+    },
+    events: {
+        subject: 'event',
+        kin: [
+            'event',
+            'celebration',
+            'party',
+            'wedding',
+            'venue',
+            'reception',
+            'gathering',
+            'decoration',
+            'banquet'
+        ],
+        broad: [
+            'event celebration',
+            'event venue decoration'
+        ]
+    },
+    fitness: {
+        subject: 'gym'
+    },
+    yoga: {
+        subject: 'yoga',
+        kin: [
+            'yoga',
+            'meditation',
+            'mindfulness',
+            'pose',
+            'mat',
+            'relaxation',
+            'stretching'
+        ],
+        broad: [
+            'yoga class',
+            'meditation'
+        ]
+    },
+    beauty: {
+        subject: 'salon',
+        kin: [
+            'salon',
+            'beauty',
+            'hair',
+            'hairdresser',
+            'makeup',
+            'nails',
+            'manicure',
+            'stylist',
+            'spa',
+            'cosmetics'
+        ],
+        broad: [
+            'beauty salon',
+            'hair salon'
+        ]
+    },
+    realestate: {
+        subject: 'real estate',
+        kin: [
+            'house',
+            'home',
+            'estate',
+            'property',
+            'interior',
+            'apartment',
+            'realtor',
+            'architecture',
+            'living'
+        ],
+        broad: [
+            'house exterior',
+            'home interior'
+        ]
+    },
+    education: {
+        subject: 'classroom',
+        kin: [
+            'classroom',
+            'student',
+            'students',
+            'education',
+            'learning',
+            'e-learning',
+            'teacher',
+            'teaching',
+            'class',
+            'lecture',
+            'study',
+            'studying',
+            'course',
+            'school',
+            'seminar',
+            'training',
+            'book',
+            'books',
+            'laptop'
+        ],
+        broad: [
+            'adult students classroom',
+            'online learning',
+            'adult education'
+        ]
+    },
+    nonprofit: {
+        subject: 'volunteers',
+        kin: [
+            'volunteer',
+            'volunteers',
+            'charity',
+            'helping',
+            'donation',
+            'nonprofit',
+            'team',
+            'people'
+        ],
+        broad: [
+            'charity volunteers',
+            'volunteers helping'
+        ]
+    },
+    music: {
+        subject: 'musician',
+        kin: [
+            'music',
+            'musician',
+            'band',
+            'concert',
+            'guitar',
+            'stage',
+            'singer',
+            'instrument',
+            'piano',
+            'drums'
+        ],
+        broad: [
+            'live music band',
+            'musician guitar'
+        ]
+    },
+    personal: {
+        subject: 'workspace',
+        kin: [
+            'workspace',
+            'desk',
+            'laptop',
+            'office',
+            'professional',
+            'notebook',
+            'coffee'
+        ],
+        broad: [
+            'workspace desk laptop',
+            'professional workspace'
+        ]
+    },
+    landing: {
+        subject: 'startup team',
+        kin: [
+            'startup',
+            'team',
+            'technology',
+            'laptop',
+            'office',
+            'workspace',
+            'business',
+            'meeting'
+        ],
+        broad: [
+            'startup team office',
+            'modern workspace'
+        ]
+    },
+    'coming-soon': {
+        subject: 'workspace',
+        kin: [
+            'workspace',
+            'desk',
+            'laptop',
+            'office',
+            'notebook',
+            'coffee'
+        ],
+        broad: [
+            'modern workspace',
+            'workspace desk laptop'
+        ]
+    }
+};
+/** Words a business's name or audience uses for a kind of site (AGL-3856): "Learning Center" is a school's. */ const NAMED_KINDS = [
+    {
+        kind: 'education',
+        words: [
+            'learning',
+            'academy',
+            'school',
+            'tutoring',
+            'tutor',
+            'tutors',
+            'college',
+            'institute',
+            'university',
+            'courses',
+            'classes',
+            'lessons',
+            'education',
+            'students',
+            'learners'
+        ]
+    },
+    {
+        kind: 'beauty',
+        words: [
+            'salon',
+            'barber',
+            'barbershop',
+            'nails',
+            'spa',
+            'lashes',
+            'brows'
+        ]
+    },
+    {
+        kind: 'realestate',
+        words: [
+            'realty',
+            'realtor',
+            'realtors',
+            'properties',
+            'homes',
+            'estate'
+        ]
+    },
+    {
+        kind: 'restaurant',
+        words: [
+            'restaurant',
+            'bistro',
+            'kitchen',
+            'grill',
+            'diner',
+            'eatery',
+            'cafe',
+            'café',
+            'tavern',
+            'pizzeria'
+        ]
+    },
+    {
+        kind: 'trades',
+        words: [
+            'plumbing',
+            'roofing',
+            'hvac',
+            'electric',
+            'electrical',
+            'landscaping',
+            'construction',
+            'contracting',
+            'remodeling',
+            'painting',
+            'handyman'
+        ]
+    },
+    {
+        kind: 'nonprofit',
+        words: [
+            'foundation',
+            'charity',
+            'church',
+            'ministry',
+            'nonprofit',
+            'volunteers'
+        ]
+    },
+    {
+        kind: 'yoga',
+        words: [
+            'yoga',
+            'meditation',
+            'mindfulness'
+        ]
+    },
+    {
+        kind: 'music',
+        words: [
+            'band',
+            'music',
+            'orchestra',
+            'choir',
+            'records'
+        ]
+    },
+    {
+        kind: 'wellness',
+        words: [
+            'wellness',
+            'therapy',
+            'massage',
+            'clinic',
+            'chiropractic',
+            'counseling'
+        ]
+    }
+];
+/** The kind of site a business's name or audience names ({@link NAMED_KINDS}), or empty. */ export function aiStockNamedKind(text) {
+    var _ref;
+    var _NAMED_KINDS_find;
+    const named = new Set(text.toLowerCase().split(/[^a-zÀ-ɏ]+/).filter(Boolean));
+    return (_ref = (_NAMED_KINDS_find = NAMED_KINDS.find((entry)=>entry.words.some((word)=>named.has(word)))) == null ? void 0 : _NAMED_KINDS_find.kind) != null ? _ref : '';
+}
+/** What a kind of site's pictures are searched and judged by ({@link KIND_SUBJECTS}); `null` for a kind not listed. */ export function aiStockKindTerms(kind) {
+    var _entry_broad;
+    var _entry_kin;
+    const entry = KIND_SUBJECTS[kind];
+    if (!entry) return null;
+    const base = aiStockSiteTerms(entry.subject);
+    if (!((_entry_kin = entry.kin) == null ? void 0 : _entry_kin.length)) return base;
+    const kin = entry.kin.map(aiStockStem);
+    return _extends({}, base, {
+        domain: [
+            ...new Set([
+                ...base.domain,
+                ...kin
+            ])
+        ],
+        broad: [
+            ...(_entry_broad = entry.broad) != null ? _entry_broad : base.broad
+        ],
+        // A hero names one of the kind's own words, never only the subject's.
+        core: [
+            ...new Set([
+                ...base.core,
+                ...kin
+            ])
+        ]
+    });
+}
+/**
+ * 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
+ * Reyes Family Law". Empty where it names none, so a name that is only a
+ * name ("Hillside") never becomes a world.
+ */ export function aiStockListedCraft(text) {
+    for (const stem of stemList(text))for (const group of CRAFT_KIN){
+        const word = group.match.find((match)=>aiStockStem(match) === stem);
+        if (word) return word;
+    }
+    return '';
 }
 /**
  * What a site in another language is searched by ({@link aiStockSourceTerms}),
@@ -2286,6 +3866,7 @@ const EXTENSIONS = {
         const avoid = new Set((_input_avoid = input.avoid) != null ? _input_avoid : []);
         /** Placed elsewhere in the job: by another page in this process, or one the caller read. */ const elsewhere = (key)=>avoid.has(key) || (job == null ? void 0 : job.has(key)) === true && job.get(key) !== scope;
         /** Source keys this page has claimed for a slot, or turned down. */ const claimed = new Set();
+        /** The photos this page's slots have claimed, first choices, by slot order. */ const shown = [];
         /** Asset srcs this page has placed. */ const placedSrcs = new Set();
         const answers = new Map();
         let searches = 0;
@@ -2308,6 +3889,12 @@ const EXTENSIONS = {
             delete request.leadWorld;
             delete request.first;
             delete request.category;
+            delete request.strict;
+            delete request.refuse;
+            delete request.needs;
+            delete request.allow;
+            delete request.refuseLead;
+            delete request.worldless;
             const key = JSON.stringify([
                 request.query,
                 request.orientation,
@@ -2414,14 +4001,51 @@ const EXTENSIONS = {
             }
             return null;
         };
-        /** How a search's hits are judged for a slot. */ const judgementFor = (slot, request, subject)=>{
+        /**
+     * How a search's hits are judged for a slot. 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).
+     */ const judgementFor = (slot, request, subject)=>{
+            var _request_refuse, _input_sectionNames_slot_sectionIndex, _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), 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. */ const judgementOf = (slot, request, subject)=>{
             var _request_subject, _request_shun;
-            var _request_shun1, _request_leadAny;
+            var _request_allow, _request_shun1, _request_leadAny, _request_refuse, _request_needs, _request_refuseLead;
             return _extends({
                 subject: (_request_subject = request.subject) != null ? _request_subject : request.broad ? '' : subject,
                 domain: terms.domain,
-                strict: slot.role === 'gallery' && !request.broad || !!request.requires,
-                named: terms.named,
+                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: terms.rivals
             }, terms.shun.length || ((_request_shun1 = request.shun) == null ? void 0 : _request_shun1.length) ? {
                 shun: [
@@ -2450,6 +4074,15 @@ const EXTENSIONS = {
                 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.worldless ? {
+                domain: [],
+                rivals: []
             } : {});
         };
         /**
@@ -2457,7 +4090,8 @@ const EXTENSIONS = {
      * filled from (AGL-3660): its broad searches, any hit naming the craft
      * itself. Never a desk, a laptop or a living room for a soap shop.
      */ const craftSearches = (slot)=>{
-            if (!terms.core.length) return [];
+            // A portfolio's record of the work is never filled by the craft's own photos (AGL-3856).
+            if (!terms.core.length || aiStockShowsTheWork(slot, terms)) return [];
             const orientation = aiStockOrientation(slot.aspect);
             const size = slot.role === 'hero' ? {
                 minWidth: 1600
@@ -2495,7 +4129,7 @@ const EXTENSIONS = {
                 ...slot.product ? aiStockProductSearches(slot, terms.craft, terms.domain, {
                     broad: terms.broad,
                     core: terms.core
-                }) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName)),
+                }) : aiStockSearchesFor(slot, terms, subject, aiStockSlotPart(slot, sectionName), sectionName),
                 ...craftSearches(slot)
             ];
             /** The slot's accepted hits for a search; `null` once the page's searches are spent. */ const accepted = async (request, repeat)=>{
@@ -2509,7 +4143,10 @@ const EXTENSIONS = {
                         if (elsewhere(key)) blocked.add(key);
                     }
                 }
-                return aiStockRank(found, blocked, `${input.seed}:${index}:${request.query}`, judgementFor(slot, request, subject));
+                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;
             };
             /** 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){
@@ -2517,7 +4154,10 @@ const EXTENSIONS = {
                     // Spent searches answer nothing; those already asked still answer from memory.
                     const ranked = await accepted(request, repeat);
                     if (!(ranked == null ? void 0 : ranked.length)) continue;
-                    if (!repeat) claimed.add(stockPhotoSourceKey(ranked[0]));
+                    if (!repeat) {
+                        claimed.add(stockPhotoSourceKey(ranked[0]));
+                        shown.push(ranked[0]);
+                    }
                     return _extends({
                         candidates: ranked.slice(0, AI_LAYOUT_STOCK_TRIES_PER_SLOT),
                         query: request.query