@agent-cards/commerce-sdk 0.15.0 → 0.17.0

package/dist/model-view.js

@@ -1,3 +1,5 @@
+import { SENTENCE_END, lastSentenceStart, leadsIn, withoutLeadIn } from './sentences.js';
+import { toMessages } from './messages.js';
 /** The steps the shopper takes on a page a link opens: the message that asks for one is one short line. */
 const STEP_ACTIONS = new Set(['store_login', 'add_card', 'approve']);
 const MODEL_STATUSES = new Set(['needs_input', 'needs_card', 'approval_sent', 'placing', 'order_placed', 'declined']);
@@ -237,6 +239,10 @@ export function forModel(result) {
         status,
         next_action: result.next_action ?? null,
         ...(result.cart_building ? { cart_building: { store: stripLinks(result.cart_building.store) } } : {}),
+        ...(result.choice ? { choice: {
+                question: result.choice.question === null ? null : stripLinks(result.choice.question),
+                groups: result.choice.groups.map((group) => ({ name: stripLinks(group.name), required: group.required, options: group.options.map((option) => `${stripLinks(option.label)}${option.price_delta_cents ? ` (+$${(option.price_delta_cents / 100).toFixed(2)})` : ''}`) })),
+            } } : {}),
         reply: replyWithoutLinks(result.reply, products.some(held) || stores.some(heldStore) || result.link_sent === true),
         cart: result.cart ? cartView(result.cart) : null,
         carts: (result.carts ?? []).map(cartView),
@@ -261,8 +267,73 @@ export function forModel(result) {
         store_pick: result.store_pick && stripLinks(result.store_pick.store_id) === result.store_pick.store_id
             ? { store_id: result.store_pick.store_id, selected: result.store_pick.selected === true }
             : null,
+        ...(yesCarriedView(result) ? { yes_carried: yesCarriedView(result) } : {}),
     };
 }
+/** The yes an answer went ahead on, as the model reads it, or null. */
+function yesCarriedView(result) {
+    const yes = result.yes_carried;
+    if (!yes || typeof yes.said_yes_to_cents !== 'number' || typeof yes.total_cents !== 'number')
+        return null;
+    const said = money(yes.said_yes_to_cents, yes.currency);
+    const total = money(yes.total_cents, yes.currency);
+    return said && total ? { said_yes_to: said, total, total_changed: yes.said_yes_to_cents !== yes.total_cents, ...(yes.picked === true ? { picked: true } : {}) } : null;
+}
+/** The link each step's ask goes with. */
+const STEP_LINK = { add_card: 'vault', approve: 'approval', store_login: 'store_login' };
+/** The items of a cart in one line, such as `1 Chicken Salad` or `2 tacos and 1 horchata`. */
+function itemsLine(cart) {
+    const lines = cart.items.map((line) => `${line.qty} ${line.name}`);
+    return lines.length <= 1 ? (lines[0] ?? '') : `${lines.slice(0, -1).join(', ')} and ${lines[lines.length - 1]}`;
+}
+/** A cart's total as the shopper reads it: `$17.43`, or `about $15.90 before tax and shipping or delivery` for an estimate. */
+function totalLine(cart) {
+    if (!cart.total_is_estimate)
+        return cart.total;
+    const before = cart.total_leaves_out ? ` before ${cart.total_leaves_out.replace(/,.*$/, '')}` : '';
+    return `about ${cart.total}${before}`;
+}
+/**
+ * The fixed short line for an answer whose next step is a link the shopper already holds: `add your card to place the
+ * order`, `sign in to DoorDash to place your order`, or `approve the payment to place your order (up to $19.02)`, with
+ * the most the shopper can be charged in the parentheses when the cart names it. After the shopper's own words put the
+ * cart together, a line about the cart comes first, as its own message. After a yes the turn carried past a step outside
+ * the chat, a total that changed opens the ask: `it's $17.89 with fees and tax now. approve the payment ...`. Null for any
+ * other answer, when the link did not go out, when the shopper already read Agentcard's own ask through `onText`, when a
+ * card or approval step has no cart to place, and when the answer also showed products.
+ */
+export function stepAsWritten(result) {
+    if (result.shopper_already_read_reply === true || result.link_sent !== true)
+        return null;
+    const next = result.next_action ?? '';
+    const kind = STEP_LINK[next];
+    const link = kind ? (result.links ?? []).find((l) => l.kind === kind && typeof l.url === 'string' && l.url !== '') : undefined;
+    if (!kind || !link)
+        return null;
+    const view = forModel(result);
+    const cart = view.cart;
+    // The line is about placing an order: an answer with no cart to place, such as the card link the shopper asked for while
+    // browsing, or one that also showed products the reply talks about, is the model's to word.
+    if ((!cart && next !== 'store_login') || view.products.length > 0)
+        return null;
+    const store = stripLinks(link.store ?? '') || cart?.store || 'the store';
+    const ask = next === 'add_card'
+        ? 'add your card to place the order'
+        : next === 'store_login'
+            ? `sign in to ${store} to place your order`
+            : `approve the payment to place your order${cart?.max_charge ? ` (up to ${cart.max_charge})` : ''}`;
+    const yes = view.yes_carried;
+    if (yes?.total_changed && cart) {
+        const total = cart.total_is_estimate ? `about ${cart.total}` : `${cart.total} with fees and tax`;
+        return `it's ${total} now. ${ask}`;
+    }
+    // Only the shopper's own words that built the cart get a line about it first; after a yes or a saved card, the ask is the whole message.
+    const agentcards = typeof result.envelope?.reply === 'string' && result.envelope.reply === result.reply;
+    if (agentcards && result.confirm_sent !== true && !yes && cart && cart.items.length > 0 && next !== 'approve') {
+        return `${itemsLine(cart)} from ${cart.store}, ${totalLine(cart)}\n\n${ask}`;
+    }
+    return ask;
+}
 /**
  * Agentcard's reply, ready for the shopper as written, when the answer only asks them something: a
  * `needs_input` answer with a reply, such as a product list, a size or a store to pick, or a cart's
@@ -271,6 +342,8 @@ export function forModel(result) {
  * itself for your model, such as the note that the cart changed or a `nextStep` turn's ask for the
  * shopper's yes: only the reply Agentcard sent, as `envelope` holds it, is written for the shopper.
  * Null as well once the shopper read the reply through `onText` (`shopper_already_read_reply`).
+ * An answer whose next step is a link the call handed over reads as that step's fixed short line
+ * instead (`stepAsWritten`), whoever wrote the reply.
  *
  * ```ts
  * replyAsWritten(result); // 'found two at Amazon. want the first one?'
@@ -280,13 +353,20 @@ export function replyAsWritten(result) {
     // The shopper already read every message of it through onText: handing it out again would say it twice.
     if (result.shopper_already_read_reply === true)
         return null;
+    // A step whose link the shopper already holds is asked for in the same short line every time, with no model.
+    const step = stepAsWritten(result);
+    if (step !== null)
+        return step;
     // The tool's own lines tell the model what to say, so only Agentcard's reply, unchanged, goes out as is.
     const agentcards = typeof result.envelope?.reply === 'string' && result.envelope.reply === result.reply;
     const view = forModel(result);
     const reply = view.reply.trim();
     if (!agentcards || view.status !== 'needs_input' || reply === '')
         return null;
-    const cards = [...view.products.filter((product) => product.link_sent).map((product) => product.name), ...view.stores.filter((store) => store.link_sent).map((store) => store.name)];
+    const cards = [
+        ...view.products.filter((product) => product.link_sent).map((product) => ({ name: product.name, price: product.price })),
+        ...view.stores.filter((store) => store.link_sent).map((store) => ({ name: store.name })),
+    ];
     // A reply with nothing left once the cards' list comes out is your model's to word.
     return withoutCardList(reply, cards) || null;
 }
@@ -294,8 +374,29 @@ export function replyAsWritten(result) {
 const LIST_ITEM = /^\s*(?:[-*•]|\d{1,2}[.)])\s+/;
 /** A price, in any of the currencies a store writes one in. */
 const PRICE = /[$£€]\s?\d/;
+/**
+ * A mark that numbers or bullets an item in the middle of a line, such as the `2)` in `1) a mug; 2) a soap`, or a `•`.
+ * A number counts only in a run that goes 1, 2, 3, so a size such as `(Pack of 12) and` marks nothing.
+ */
+const INLINE_MARK = /(?<=^|[\s:;,(])(?:(\d{1,2})([.)])|•)[ \t]+/g;
+/**
+ * A sentence that asks the shopper something: a question, `let me know ...` or `tell me ...` anywhere in it, as in
+ * `amazon has the best price, so let me know how many you want.`, or one that opens with `pick ...` or `reply ...`.
+ */
+const ASKS = /\?[\s"'*_)\]]*$|\b(?:let me know|tell me)\b|^[\s*_"'(]*(?:just (?:say|tell|reply|pick)|reply|pick|choose)\b/i;
+/** A clause that turns from a product to the shopper, after a comma, a semicolon or a dash: `, which one would you like?`. */
+const ASKING_CLAUSE = /(?:[,;]|\s[-–])\s+(?=(?:(?:and|or|so|but)\s+)?(?:which|what|want|would|do|does|should|shall|can|could|how|any|let me know|tell me|just)\b)/gi;
 /** The place a sentence points at in a numbered list, such as `#8` or `number 3`, where `a #2 Phillips head` names a kind of thing. */
 const LIST_NUMBER = /(?<!\ba )(?<!\ban )(?:#(\d{1,2})\b|\bnumber (\d{1,2})\b)/i;
+/**
+ * A sentence that goes on to more of the list rather than recommending: `other 6-packs are ...`, `other options include ...`,
+ * `there's also ...`, `you could also ...`. One that names a card is the list, whatever the reply recommended before it.
+ */
+const MORE_OF_LIST = /^[\s*_"'(]*(?:(?:and|plus|but|or)\s+)?(?:others?\b[^.!?:]{0,40}?\b(?:are|is|include|includes|would be)\b|there(?:'s|’s|\s+is|\s+are)\s+also\b|(?:you|we)\s+(?:could|can|might)\s+also\b)/i;
+/** An amount a text gives after a currency sign, such as `$22.89` or `¥1,331`. */
+const AMOUNT = /[$£€¥]\s?(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?/g;
+/** Words that tell no product from another: a card's brand or its distinctive words are never one of these. */
+const FILLER = new Set(['the', 'and', 'with', 'for', 'from', 'of', 'by', 'in', 'on', 'to', 'or', 'at', 'an', 'new', 'pack', 'count', 'set', 'each', 'size']);
 /** A unit a size or a count is written in, so `10 ft`, `10-ft` and `10ft` read as one word. */
 const UNIT = /(\d)[\s-]+(ft|feet|foot|inch|inches|oz|fl|ml|l|g|kg|lb|lbs|gb|tb|mb|w|mah|v|cm|mm|m|pack|pk|ct|count|pcs|pieces)\b/gi;
 /**
@@ -305,6 +406,8 @@ const UNIT = /(\d)[\s-]+(ft|feet|foot|inch|inches|oz|fl|ml|l|g|kg|lb|lbs|gb|tb|m
 const SAME_UNIT = new Map([['feet', 'ft'], ['foot', 'ft'], ['in', ''], ['inch', ''], ['inches', ''], ['pk', 'pack'], ['ct', 'pack'], ['count', 'pack'], ['pcs', 'pack'], ['pieces', 'pack'], ['lbs', 'lb']]);
 /** A size or a count written as one word, such as `24pack` or `10ft`. */
 const SIZE = /^(\d+)(\p{L}+)$/u;
+/** A size in inches, however a text writes it: `10 inch`, `10-inches`, `10in`, `10 in`. */
+const INCHES = /(\d+)\s*-?\s*(?:inch(?:es)?|in)\b/gi;
 /** A text's words, lowercased, letters and digits only, with markdown's bold marks gone and a size written as one word. */
 function wordsOf(text) {
     return text
@@ -314,29 +417,225 @@ function wordsOf(text) {
         .filter((word) => word !== '')
         .map((word) => word.replace(SIZE, (whole, count, unit) => `${count}${SAME_UNIT.get(unit) ?? unit}`));
 }
+/** An amount in hundredths, so `$26.46`, `from $26.46` and `26.46` all read 2646, and `¥1,331` reads 133100. */
+function hundredths(whole, fraction) {
+    return Math.round(Number(`${whole.replace(/,/g, '')}${fraction ?? ''}`) * 100);
+}
+/** The amounts a text gives after a currency sign, in hundredths. */
+function amountsIn(text) {
+    return new Set([...text.matchAll(AMOUNT)].map((match) => hundredths(match[1], match[2])));
+}
 /**
- * The card a text names, by the first six words of the card's name: at least two of them, and most of them, in the
- * text. Null when it names none. A name of one word never counts in prose, where a generic word such as `soap` would.
- * A size or a count among those words has to be in the text too, so the 3ft cable's line never reads as the 10ft card.
+ * The sizes among a text's words, by unit: `10ft` and `3ft` are two sizes in feet, `24pack` a count. Inches come from
+ * the text itself, because `wordsOf` leaves `10 inch` as the bare `10`, so the 10 inch skillet reads as one size in
+ * inches and the 12 inch one as another.
  */
-function cardNamed(text, cards, inList) {
-    const said = new Set(wordsOf(text));
-    for (const [index, name] of cards.entries()) {
-        const head = name.slice(0, 6);
-        if (!head.every((word) => !/\d/.test(word) || said.has(word)))
-            continue;
-        const hits = head.filter((word) => said.has(word)).length;
-        if (head.length === 1 ? inList && hits === 1 : hits >= Math.max(2, Math.ceil(head.length * 0.6)))
-            return index;
+function sizesOf(words, text) {
+    const sizes = new Map();
+    for (const word of words) {
+        const [, count, unit] = /^(\d+)(\p{L}+)$/u.exec(word) ?? [];
+        if (count && unit)
+            sizes.set(unit, (sizes.get(unit) ?? new Set()).add(count));
+    }
+    for (const [, count] of text.matchAll(INCHES))
+        sizes.set('inch', (sizes.get('inch') ?? new Set()).add(count));
+    return sizes;
+}
+function readCards(shown) {
+    const named = shown
+        .map((card) => (typeof card === 'string' ? { name: card, price: null } : { name: String(card?.name ?? ''), price: card?.price ?? null }))
+        .map((card) => ({ name: card.name, words: wordsOf(card.name), price: card.price }))
+        .filter((card) => card.words.length > 0);
+    const holders = new Map();
+    for (const card of named)
+        for (const word of new Set(card.words))
+            holders.set(word, (holders.get(word) ?? 0) + 1);
+    const telling = (word) => word.length >= 3 && !/\d/.test(word) && !FILLER.has(word);
+    return named.map(({ name, words, price }) => {
+        const brand = words.find((word) => /\p{L}/u.test(word) && word.length >= 2 && !FILLER.has(word)) ?? null;
+        const amount = typeof price === 'string' ? /(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?/.exec(price) : null;
+        return {
+            words,
+            head: words.slice(0, 6),
+            brand,
+            marks: new Set([...(brand ? [brand] : []), ...words.filter((word) => telling(word) && (holders.get(word) ?? 0) <= Math.max(1, named.length / 2))]),
+            price: amount ? hundredths(amount[1], amount[2]) : null,
+            sizes: sizesOf(words, name),
+        };
+    });
+}
+/**
+ * The cards a text names, by their indexes; empty when it names none. A text names a card in one of three ways:
+ *
+ * - By the first six words of the card's name: at least two of them, and most of them, in the text. A name of one word
+ *   never counts in prose, where a generic word such as `soap` would. A size or a count among those words has to be in
+ *   the text too, so the 3ft cable's line never reads as the 10ft card.
+ * - By the card's exact price with its brand or another word that tells it apart: `Planet Oat Extra Creamy ($22.89)`
+ *   names the card `Planet Oat Extra Creamy Oatmilk, 32 Fl Oz (Pack of 6)` at $22.89. A price alone, as on a line of
+ *   sizes, names nothing.
+ * - By its brand and two more of its first six words, when the text gives no price or gives the card's.
+ *
+ * The last two take a short name a reply writes for a long title, and neither counts when the text gives a size the card
+ * has in another number, such as 3ft for its 10ft. A text that gives prices, none of them the card's, names it only by
+ * the first six words, so a line for a product no card shows keeps its place beside the card of its brand.
+ * 2026-10-27, "Oat milk, shelf stable, a 6 pack": "Planet Oat Extra Creamy ($22.89)" shares too few of its title's first
+ * six words to match by them alone.
+ */
+function cardsNamed(text, cards, inList) {
+    const words = wordsOf(text);
+    // Each word with how often the text says it, so a name of one word twice over, `Miu Miu`, counts twice.
+    const said = new Map();
+    for (const word of words)
+        said.set(word, (said.get(word) ?? 0) + 1);
+    const amounts = amountsIn(text);
+    const sizes = sizesOf(words, text);
+    const found = [...cards.entries()].flatMap(([index, card]) => {
+        const { head } = card;
+        const shared = head.filter((word) => said.has(word));
+        const hit = new Set(shared);
+        if (head.every((word) => !/\d/.test(word) || said.has(word))) {
+            if (head.length === 1 ? inList && shared.length === 1 : shared.length >= Math.max(2, Math.ceil(head.length * 0.6)))
+                return [{ index, hit }];
+        }
+        const otherSize = [...card.sizes].some(([unit, counts]) => sizes.has(unit) && ![...counts].some((count) => sizes.get(unit).has(count)));
+        if (otherSize)
+            return [];
+        const ownPrice = card.price !== null && amounts.has(card.price);
+        if (ownPrice && [...card.marks].some((word) => said.has(word)))
+            return [{ index, hit }];
+        const otherPrice = amounts.size > 0 && !ownPrice;
+        const more = new Set(head.filter((word) => word !== card.brand && word.length >= 2 && !FILLER.has(word) && said.has(word)));
+        return !otherPrice && card.brand !== null && said.has(card.brand) && more.size >= 2 ? [{ index, hit }] : [];
+    });
+    // Cards whose names share their words read as several products where the text names one, as three Kirkland Signature
+    // Organic milks do for `Kirkland Signature Organic Almond Milk`: a card the text names in nothing but another card's
+    // words, each said once, is that card's mention, and counts for no product of its own. A text that says those words
+    // again names both products, as `Diamond Walnut Pieces ($5.99) and Diamond Walnut Pieces Halves ($7.99)` does.
+    const saidOnce = (hit) => [...hit].every((word) => said.get(word) === 1);
+    return found
+        .filter(({ hit }) => hit.size === 0 || !saidOnce(hit) || !found.some((other) => other.hit.size > hit.size && [...hit].every((word) => other.hit.has(word))))
+        .map(({ index }) => index);
+}
+/** The sentences of a text from `from` on, each with the place in the text where it starts. */
+function sentencesAt(text, from) {
+    const out = [];
+    let at = from;
+    for (const part of text.slice(from).split(SENTENCE_END)) {
+        const start = text.indexOf(part, at);
+        if (part !== '')
+            out.push({ text: part, at: start });
+        at = start + part.length;
+    }
+    return out;
+}
+/**
+ * Where the clause that asks the shopper starts in a sentence that also gives a product, as `which one would you like?`
+ * does in `2) Mini Soaps Gift Box ($58.00), which one would you like?`, or null when the sentence asks nothing apart.
+ */
+function askingClause(sentence) {
+    if (!ASKS.test(sentence))
+        return null;
+    for (const turn of sentence.matchAll(ASKING_CLAUSE)) {
+        const rest = sentence.slice(turn.index + turn[0].length);
+        if (ASKS.test(rest) && !PRICE.test(rest))
+            return turn.index + turn[0].length;
     }
     return null;
 }
+/** Where the sentence that holds `at` starts: right after the sentence before it, or at the line's start. */
+function sentenceStart(line, at) {
+    return lastSentenceStart(line.slice(0, at));
+}
+/**
+ * Where a list on one line stops, given where its last item starts: past that item's first period, through the
+ * sentences that only describe it, to the first that asks the shopper or names a card itself, so `8.4 Fl. Oz.` never
+ * cuts the item short. A question the item's own sentence asks after a comma, `..., which one?`, stays out of it.
+ */
+function inlineEnd(line, from, cards) {
+    const [own, ...rest] = sentencesAt(line, from);
+    const clause = own ? askingClause(own.text) : null;
+    if (own && clause !== null)
+        return own.at + clause;
+    const stop = rest.find((sentence) => ASKS.test(sentence.text) || cardsNamed(sentence.text, cards, false).length > 0);
+    return stop ? stop.at : line.length;
+}
+/**
+ * A list a reply writes on one line, mid-sentence: `i found a few options: 1) a mug ($19.00); 2) a gift set ($115.00);
+ * 3) a soap box ($58.00). which one?`. Its items are numbered `1)` or `1.`, bulleted with `•`, or set apart by `;` with
+ * each naming a card, after a colon or three of them at least. The list may open the line, `1) a mug; 2) a candle`, and
+ * ends where inlineEnd says. `lead` is where the sentence that leads into the list starts, `end` where the list stops.
+ * Null when the line holds no such list.
+ */
+function inlineList(line, cards) {
+    const marks = [...line.matchAll(INLINE_MARK)];
+    // A numbered run, 1, 2, 3, each marked the same way, or two or more bullets.
+    const run = [];
+    for (const mark of marks) {
+        if (mark[1] !== undefined && Number(mark[1]) === run.length + 1 && (run.length === 0 || run[0][2] === mark[2]))
+            run.push(mark);
+    }
+    const bullets = marks.filter((mark) => mark[1] === undefined);
+    const chosen = run.length >= 2 ? run : bullets.length >= 2 ? bullets : [];
+    if (chosen.length >= 2) {
+        const last = chosen[chosen.length - 1];
+        const end = inlineEnd(line, last.index + last[0].length, cards);
+        const items = chosen.map((mark, k) => {
+            const start = mark.index;
+            const raw = line.slice(start, k + 1 < chosen.length ? chosen[k + 1].index : end);
+            return { start, raw, body: raw.slice(mark[0].length), number: mark[1] === undefined ? null : Number(mark[1]) };
+        });
+        return { lead: sentenceStart(line, items[0].start), items, end };
+    }
+    // Parts set apart by `;` run from the colon that leads into them, found by its place rather than by sentences, so a
+    // name such as `8.4 Fl. Oz.` before the first `;` stays whole.
+    const semicolon = line.indexOf(';');
+    if (semicolon === -1)
+        return null;
+    const colon = line.lastIndexOf(':', semicolon);
+    const led = colon !== -1 && !/[?!]/.test(line.slice(colon, semicolon));
+    const opens = led ? colon + 1 : sentenceStart(line, semicolon);
+    // The list's last `;` is the last one with an item on its right and no question between, found before the list's end
+    // is, so a sentence inside an item, `The Lavender Candle ships free;`, never ends the list early, and a `;` in a
+    // question after it, `which one would you like; or should i search again?`, is no part of it. An item names a card
+    // the list has not named yet, or names one again with a price, `Travel Mug ($19.00)`; a part that names a listed
+    // card with no price is a recommendation after the list, `i'd pick Travel Mug; Lavender Candle is nicer.`, and stays.
+    let last = semicolon;
+    for (let next = line.indexOf(';', last + 1); next !== -1; next = line.indexOf(';', last + 1)) {
+        const after = line.indexOf(';', next + 1);
+        const asks = sentencesAt(line.slice(0, next), last + 1).some((sentence) => ASKS.test(sentence.text));
+        const listed = new Set(cardsNamed(line.slice(opens, next), cards, true));
+        const text = line.slice(next + 1, after === -1 ? line.length : after);
+        const part = cardsNamed(text, cards, true);
+        const item = part.some((index) => !listed.has(index)) || (part.length > 0 && PRICE.test(sentencesAt(text, 0)[0]?.text ?? ''));
+        if (asks || !item)
+            break;
+        last = next;
+    }
+    const end = inlineEnd(line, last + 1, cards);
+    const parts = line.slice(opens, end).replace(/[\s,;]+$/, '').split(';');
+    if ((!led && parts.length < 3) || !parts.every((part) => cardsNamed(part, cards, true).length > 0))
+        return null;
+    let start = opens;
+    const items = parts.map((part) => {
+        const item = { start, raw: part, body: part, number: null };
+        start += part.length + 1;
+        return item;
+    });
+    return { lead: led ? sentenceStart(line, colon) : opens, items, end };
+}
 /**
  * Agentcard's reply without the list its cards already show the shopper: each list line that names a product or
  * store whose card went out, the line that led into that list (`here are a few:`, `other choices:`), a sentence that
- * points at a number the list gave (`the dishwand in #8`), and, past the one or two products a reply recommends in
- * words, each further sentence that names another card. What is left is the reply around the list, such as `found
- * these at amazon.` and `which one do you want?`. A reply whose cards went out names none of them twice over.
+ * points at a number the list gave (`the dishwand in #8`), a sentence that goes on to more of the list (`other 6-packs
+ * are ...`, `there's also ...`) and names a card, and, past the one or two products a reply recommends in words, each
+ * further sentence that names another card. A list written on one line goes the same way, item by item (inlineList),
+ * and so does a list line written without a bullet, whole, up to the question on it. What is left is the reply around
+ * the list, such as `found these at amazon.` and `which one do you want?`. A reply whose cards went out names none of
+ * them twice over. A list that keeps an item for a product no card shows keeps its lead-in, and the two read as one
+ * message (toMessages), so the shopper never reads `two options came in under $20:` on its own.
+ *
+ * Each card is its name, or its name and its price as the model reads it (`{ name, price: '$22.89' }`): with the price,
+ * a reply's short name for the product, such as `Planet Oat Extra Creamy ($22.89)`, reads as its card (cardsNamed).
  *
  * ```ts
  * withoutCardList('Two I'd suggest:\n- Duracell AA, 24 pack, $20.78\n\nWhich one?', ['Duracell AA Batteries, 24 Count']);
@@ -344,33 +643,69 @@ function cardNamed(text, cards, inList) {
  * ```
  */
 export function withoutCardList(reply, cardNames) {
-    const cards = cardNames.map(wordsOf).filter((name) => name.length > 0);
+    const cards = readCards(cardNames);
     if (cards.length === 0)
         return reply.trim();
     // A text that opens with a card's name and gives its price is a list line, as a reply writes one without a bullet.
     const opensCard = (text) => {
         const words = wordsOf(text);
-        return PRICE.test(text) && cards.some((name) => name.length >= 2 && name.slice(0, 3).every((word, i) => words[i] === word));
+        return PRICE.test(text) && cards.some((card) => card.words.length >= 2 && card.words.slice(0, 3).every((word, i) => words[i] === word));
+    };
+    // The numbers the dropped list gave, so a number of a product's own, `a #2 Phillips head`, keeps its sentence.
+    const numbers = new Set();
+    // A list a line writes inline goes the way a list of lines does: each item that names a card, and the sentence that
+    // led into the list once every item went. An item for a product no card shows stays, with the lead, and so does a
+    // list that opens the line, `1) a mug; 2) a candle; 3) a soap box`, item by item rather than as one list line.
+    const unlisted = (line) => {
+        const list = inlineList(line, cards);
+        const gone = list?.items.map((item) => cardsNamed(item.body, cards, true).length > 0) ?? [];
+        if (!list || !gone.some(Boolean))
+            return line;
+        list.items.forEach((item, k) => {
+            if (gone[k] && item.number !== null)
+                numbers.add(item.number);
+        });
+        const after = line.slice(list.end).trimStart();
+        if (gone.every(Boolean))
+            return `${line.slice(0, list.lead).trimEnd()} ${after}`.trim();
+        const left = list.items.filter((_, k) => !gone[k]).map((item) => item.raw.trim().replace(/[\s,;]*(?:\b(?:and|or))?[\s,;]*$/i, ''));
+        const close = /[.!?]$/.test(left[left.length - 1]) ? '' : '.';
+        return [line.slice(0, list.items[0].start).trimEnd(), `${left.join('; ')}${close}`, after].filter((part) => part !== '').join(' ');
     };
-    const lines = reply.split('\n');
+    const lines = reply.split('\n').map(unlisted);
     const kind = lines.map((line) => {
         if (LIST_ITEM.test(line))
-            return cardNamed(line.replace(LIST_ITEM, ''), cards, true) !== null ? 'item' : 'kept';
+            return cardsNamed(line.replace(LIST_ITEM, ''), cards, true).length > 0 ? 'item' : 'kept';
         return opensCard(line) ? 'named' : 'kept';
     });
     const dropped = kind.map((of) => of !== 'kept');
-    // The numbers the dropped list gave, so a number of a product's own, `a #2 Phillips head`, keeps its sentence.
-    const numbers = new Set(lines.flatMap((line, i) => (dropped[i] ? [Number(/^\s*(\d{1,2})[.)]\s/.exec(line)?.[1])] : [])).filter((number) => Number.isInteger(number)));
+    lines.forEach((line, i) => {
+        const number = dropped[i] ? Number(/^\s*(\d{1,2})[.)]\s/.exec(line)?.[1]) : NaN;
+        if (Number.isInteger(number))
+            numbers.add(number);
+    });
     // The list a line leads into: the lines from the next one with words on it to the first that is not a list line, so a
-    // question on the line after the last item, `Which one?`, is no part of the list.
+    // question on the line after the last item, `Which one?`, is no part of the list. A blank line between two list lines
+    // is no end of it, as toMessages reads one, so a list that keeps an item past the blank keeps its lead.
+    const listLine = (j) => LIST_ITEM.test(lines[j]) || kind[j] === 'named';
     const listAfter = (line) => {
         const start = lines.findIndex((after, j) => j > line && after.trim() !== '');
         if (start === -1)
             return [];
-        let end = start;
-        while (end < lines.length && (LIST_ITEM.test(lines[end]) || kind[end] === 'named'))
-            end += 1;
-        return dropped.slice(start, end);
+        const list = [];
+        for (let j = start; j < lines.length; j += 1) {
+            if (listLine(j)) {
+                list.push(dropped[j]);
+                continue;
+            }
+            if (lines[j].trim() !== '')
+                break;
+            // A blank line: the list goes on when the next line with words on it is a list line.
+            const next = lines.findIndex((after, k) => k > j && after.trim() !== '');
+            if (next === -1 || !listLine(next))
+                break;
+        }
+        return list;
     };
     const named = new Set();
     const kept = [];
@@ -381,29 +716,44 @@ export function withoutCardList(reply, cardNames) {
         // The line that leads into a list whose every line went loses the sentence that leads in: `Two I'd suggest:` or
         // `Other choices:`. A list that keeps a line, for a product no card shows, keeps its lead too.
         const list = listAfter(i);
-        if (text.trim().endsWith(':') && list.length > 0 && list.every(Boolean))
-            text = text.trim().replace(/(?:^|(?<=[.!?])\s+)[^.!?]*:$/, '');
-        const sentences = text.split(/(?<=[.!?])\s+/).filter((sentence) => {
+        if (leadsIn(text) && list.length > 0 && list.every(Boolean))
+            text = withoutLeadIn(text);
+        // A list line written without a bullet goes whole, with what trails its card's price (`$16.12. amazon, and the
+        // cheapest multipack.`), up to the sentence that asks the shopper something, which stays with what follows it. A
+        // question its card's own sentence asks after a comma, `..., $16.12, want it?`, stays too.
+        let asked = false;
+        const sentences = text.split(SENTENCE_END).flatMap((sentence) => {
             const place = LIST_NUMBER.exec(sentence);
             if (place && numbers.has(Number(place[1] ?? place[2])))
-                return false;
-            const card = cardNamed(sentence, cards, false);
-            // A list line written without a bullet keeps the sentences its card does not say, such as the question after it.
-            if (kind[i] === 'named')
-                return card === null && !opensCard(sentence);
-            if (card === null || named.has(card))
-                return true;
+                return [];
+            const found = cardsNamed(sentence, cards, false);
+            if (kind[i] === 'named') {
+                const card = found.length > 0 || opensCard(sentence);
+                asked ||= ASKS.test(sentence);
+                if (!card)
+                    return asked ? [sentence] : [];
+                const clause = asked ? askingClause(sentence) : null;
+                return clause === null ? [] : [sentence.slice(clause)];
+            }
+            if (found.length === 0)
+                return [sentence];
+            // `other 6-packs are ...` and `there's also ...` recommend nothing: they are the list again, in a sentence.
+            if (MORE_OF_LIST.test(sentence))
+                return [];
+            const fresh = found.filter((card) => !named.has(card));
             // A reply recommends one or two products in words; a sentence that names a third is the list again.
-            if (named.size >= 2)
-                return false;
-            named.add(card);
-            return true;
+            if (named.size + fresh.length > 2)
+                return [];
+            for (const card of fresh)
+                named.add(card);
+            return [sentence];
         });
         if (kind[i] === 'named' && sentences.length === 0)
             return;
         kept.push(sentences.join(' ').trimEnd());
     });
-    return kept.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+    // A lead-in kept for a list that lost an item to a card goes with what is left of the list, as one message (toMessages).
+    return toMessages(kept.join('\n')).join('\n\n');
 }
 /**
  * A thrown error as the model may read it: the same message with every link