echelongraph-mcp 3.0.0 → 3.1.0

package/dist/textBudget.js

@@ -32,9 +32,20 @@ import * as z from "zod";
 //      in "…", every list in it to its first `cap` entries); then, for a tool that names the
 //      lists beside its rows (`sides`: check_affected's excluded sample, check_sbom's
 //      not_sent_purls), the same level with those lists cut as it says; then each next level with
-//      them cut; and when no level fits, rows are left out of the text, those the tool names
-//      first, then from the end. A list beside the rows is cut before any row field the first
-//      level keeps, and before any row leaves the text;
+//      them cut; and when no level fits, the lists beside the rows that the tool names
+//      beforeRows (#3272: cve_remediation's fixed_branches, patches and fix_references, which its
+//      structured cut thins and leaves in the same order) are cut as each says, one after another,
+//      then (3.1.0's phase A review, `capped`: fixed_branches) each entry's own list is cut to its
+//      first c entries, the most that fit, every entry kept and marked as the structured cut
+//      marks it, and then they lose entries from the end, the last named first, the room left
+//      going back to c; then rows are left out of the
+//      text, those the tool names first, then from the end, those it names last (leaveOutLast,
+//      #2899: check_affected's KEV-listed and ransomware matches) only after every other, the note
+//      naming each of those left out. A list the tool names beside its rows is cut before any row
+//      leaves the text, and, unless it is named beforeRows, before any row field the first level
+//      keeps (a list it does not name is cut only in step 4).
+//      With outFirstBefore (#3269: check_sbom), the rows the tool names are cut to the leanest
+//      level and leave first, as many as must, before any other row is cut to the level it names;
 //   4. else every list keeps its first n entries, n halving, and then strings are cut too.
 // Whenever the text is not the JSON whole, the note ends with one sentence, starting TEXT CUT,
 // that says what the first text block leaves out, where structuredContent.data carries all of it,
@@ -62,7 +73,21 @@ import * as z from "zod";
 //      the tool names leave first (the clean rows, counted in data.summary), then the last of the
 //      rest, or for a step of series named keepNewest (exposure_radar's daily and weekly counts,
 //      which the API sends oldest first) its last ones, the newest, the oldest leaving first; a
-//      step that cannot fit even empty is emptied, and the next one is cut;
+//      step that cannot fit even empty is emptied, and the next one is cut. A level can cut inside
+//      each entry on its own terms (an EntryLevel, #3132: check_sbom's rows keep at most the same
+//      number of matches, the most that fit, so only the rows with more lose any), and a step named
+//      keepAll (#3139: cve_remediation's vendor_remediations) keeps every entry at its leanest level
+//      while the later steps are cut, its entries leaving only once they all are; and a step named
+//      with outFirst (#3269: check_sbom's results) sends the entries leaveOutFirst names out, cut
+//      lean, before the others are cut past a given level, and has them back with the room left,
+//      but (#3269's review, outFirst.floor) keeps them while the others, capped anyway, fit at a
+//      floor; and a tool that pages names the page size at which a call of its first entries keeps
+//      them all (PageAt.firstFit), counted as this cut would cut that call; #3269's second review:
+//      with EntryLevel.floor and leaveAt's floor no entry's list goes below its floor, the entries
+//      leave whole instead, chosen by fit, those DataCutStep.leaveLast holds kept first, and the
+//      note names by id those of them that left (#3269's third review: those it holds first and
+//      apart, and, where the tool gives the sentence, the sizes of calls of them alone that keep
+//      every one, PageAt.againFit);
 //   2. then every other list at the top level of data, the same way. A list inside an object of
 //      data (get_cve's remediation summary, with fix_status, #2841) is cut only where a DataCut
 //      names it, and none names get_cve's. Once a step fits, the room it leaves goes back to the
@@ -70,7 +95,9 @@ import * as z from "zod";
 //      emptied while its rows were whole, keeps its entries once the thinned rows fit);
 //   3. no string is shortened and no value changes: a thinned entry keeps some of its fields as
 //      they are (every field a thinning level drops is optional in the outputSchema, so data still
-//      validates against it), and no field outside the lists cut changes; the envelope says
+//      validates against it), and no field outside the lists cut changes (the one field a cut
+//      adds is an EntryLevel's mark, check_sbom's matches_truncated, which says what the row's own
+//      cut left out, and which its outputSchema names); the envelope says
 //      data_truncated true, truncated gives each list cut by its path in data with its total, the
 //      number returned and, where its entries are thinned, thinned true, and the note ends with
 //      sentences starting DATA CUT that say what was cut and to which fields, how to read the rest
@@ -118,11 +145,12 @@ function cutValue(v, clip, cap, s) {
     if (typeof v === "string") {
         if (v.length <= clip)
             return v;
-        s.clipped++;
+        if (s)
+            s.clipped++;
         return clipString(v, clip);
     }
     if (Array.isArray(v)) {
-        if (v.length > cap)
+        if (s && v.length > cap)
             s.capped++;
         return v.slice(0, cap).map((x) => cutValue(x, clip, cap, s));
     }
@@ -130,18 +158,31 @@ function cutValue(v, clip, cap, s) {
         return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, cutValue(x, clip, cap, s)]));
     return v;
 }
+// A RowKeep as the fields it names, each with its subfields (null: kept whole), built once per
+// RowKeep (3.0.2: through 3.0.1, once per row cut; a 2,000-row answer's structured cut built it
+// some 12,000 times). A RowKeep is never changed once built.
+const wantedOf = (() => {
+    const built = new WeakMap();
+    return (keep) => {
+        let wanted = built.get(keep);
+        if (!wanted)
+            built.set(keep, (wanted = new Map(keep.map((k) => (typeof k === "string" ? [k, null] : [k[0], k[1]])))));
+        return wanted;
+    };
+})();
 function cutRow(row, keep, level, s, prefix = "") {
-    const wanted = new Map(keep.map((k) => (typeof k === "string" ? [k, null] : [k[0], k[1]])));
+    const wanted = wantedOf(keep);
     const cap = level.cap ?? Number.POSITIVE_INFINITY;
     const out = {};
-    for (const [k, v] of Object.entries(row)) {
+    for (const k of Object.keys(row)) {
+        const v = row[k];
         if (!wanted.has(k)) {
-            s.left.add(`${prefix}${k}`);
+            s?.left.add(`${prefix}${k}`);
             continue;
         }
         const sub = wanted.get(k);
         if (sub && Array.isArray(v)) {
-            if (v.length > cap)
+            if (s && v.length > cap)
                 s.capped++;
             out[k] = v.slice(0, cap).map((e) => (isPlainObject(e) ? cutRow(e, sub, level, s, `${prefix}${k}[].`) : cutValue(e, level.clip, cap, s)));
         }
@@ -222,6 +263,7 @@ export const FIRST_TEXT_BLOCK = {
 export const FIRST_TEXT_BLOCK_BESIDE_A_CUT = {
     opens: (chars) => `TEXT CUT: the API's answer is ${chars} characters of JSON, more than the ${DATA_TEXT_BUDGET} the first text block holds, so that block is cut, and structuredContent.data carries the answer whole with full: true (DATA CUT, below).`,
     leftOut: (n, which) => `the other ${n} are left out of it${which}, and structuredContent.data holds them with full: true`,
+    full: true,
 };
 /** The first text block for `data` within DATA_TEXT_BUDGET, and the TEXT CUT sentence when it is cut. */
 export function dataText(data, cut, place = FIRST_TEXT_BLOCK) {
@@ -241,59 +283,271 @@ export function dataText(data, cut, place = FIRST_TEXT_BLOCK) {
     if (cut && isPlainObject(data) && Array.isArray(rows) && rows.length > 0 && cut.levels.length > 0) {
         const n = rows.length;
         // The lists beside the rows, cut once; tried with the first level after it fails with them
-        // whole, and with every later level.
-        const sides = cut.sides?.length ? cutSides(data, cut.sides) : { fields: {}, said: [] };
+        // whole, and with every later level. (Those named beforeRows, #3272, are cut only below.)
+        const early = (cut.sides ?? []).filter((side) => !side.beforeRows);
+        const sides = early.length ? cutSides(data, early) : { fields: {}, said: [] };
         const sided = sides.said.length > 0;
         const attempts = cut.levels.flatMap((level, i) => (i === 0 && sided ? [{ level, sided: false }, { level, sided: true }] : [{ level, sided }]));
+        // The order rows leave the text in: those the tool names first (by value, in its order, each
+        // from the end), then the rest from the end.
+        const firstOut = cut.leaveOutFirst;
+        const isNamed = (i) => firstOut !== undefined && firstOut.values.includes(String(field(rows[i], firstOut.field)));
+        const lastOut = cut.leaveOutLast;
+        const isLast = (i) => lastOut !== undefined && (lastOut.fields.some((f) => field(rows[i], f) === true) || lastOut.has?.(rows[i]) === true);
+        // What a row named last has, as the note says it: "kev_listed or ransomware true" (#2899), or
+        // the tool's own words (#3284: "a KEV-listed or ransomware match").
+        const lastHas = lastOut ? (lastOut.said ?? `${orListed(lastOut.fields)} true`) : "";
+        const lastWhose = lastOut ? (lastOut.said ? `with ${lastOut.said}` : `whose ${orListed(lastOut.fields)} is true`) : "";
+        const lastWithout = lastOut ? (lastOut.said ? `without ${lastOut.said}` : `whose ${orListed(lastOut.fields)} is not true`) : "";
+        const order = [];
+        for (const value of firstOut?.values ?? []) {
+            for (let i = n - 1; i >= 0; i--)
+                if (field(rows[i], firstOut?.field ?? "") === value)
+                    order.push(i);
+        }
+        const named = order.length;
+        const queued = new Set(order);
+        for (let i = n - 1; i >= 0; i--)
+            if (!queued.has(i) && !isLast(i))
+                order.push(i);
+        for (let i = n - 1; i >= 0; i--)
+            if (!queued.has(i) && isLast(i))
+                order.push(i);
+        // Rows leave `cutRows` in that order, the first `upTo` of it at most, until the text fits; the
+        // answer so cut, its sentences after those `said` gives for the number of named rows that left,
+        // or undefined where it does not fit.
+        const leaving = (cutRows, beside, said, upTo = n) => {
+            const lens = cutRows.map((r) => 4 + JSON.stringify(r).length);
+            const emptyLen = lined({ ...beside, [cut.rows]: [] }).length;
+            const textLen = (kept, sum) => (kept === 0 ? emptyLen : emptyLen + 2 + sum + 2 * kept);
+            const out = new Set();
+            let sum = lens.reduce((t, x) => t + x, 0);
+            for (const i of order.slice(0, upTo)) {
+                if (textLen(n - out.size, sum) <= DATA_TEXT_BUDGET)
+                    break;
+                out.add(i);
+                sum -= lens[i];
+            }
+            const kept = cutRows.filter((_, i) => !out.has(i));
+            const shown = lined({ ...beside, [cut.rows]: kept });
+            if (kept.length === 0 || shown.length > DATA_TEXT_BUDGET)
+                return undefined;
+            const outFirst = [...out].filter(isNamed).length;
+            // #2899: the rows left out are the last in order unless a row named last stayed behind them.
+            const inOrder = [...out].every((i) => i >= n - out.size);
+            // #3284: the same of the rows left out that the tool does not name first: the last of the
+            // rest unless a row named last stayed behind them.
+            const restOut = [...out].filter((i) => !isNamed(i));
+            const restIdx = [...Array(n).keys()].filter((i) => !isNamed(i));
+            const restInOrder = restOut.every((i) => restIdx.indexOf(i) >= restIdx.length - restOut.length);
+            const butLast = lastOut ? ` but for any ${lastWhose}${lastOut.why ? ` (${lastOut.why})` : ""}, which leave it last` : "";
+            // #3284: the rest, where a row named last stayed behind them: the last of those without one,
+            // or, where rows named last left too, each without one and then the last of those with one
+            // (said short: the note counts against the structured result's budget).
+            const lastOutN = [...out].filter(isLast).length;
+            const restOf = (m) => restInOrder || !lastOut
+                ? `, and the last ${m} of the rest`
+                : lastOutN === 0
+                    ? `, and the last ${m} of the rest ${lastWithout}`
+                    : `, and ${m} of the rest: each ${lastWithout}, then the last ${lastOutN} ${lastWhose}`;
+            const which = outFirst > 0
+                ? `: the ${outFirst} whose ${firstOut?.field} is ${(firstOut?.values ?? []).join(" or ")} (${firstOut?.why})${out.size > outFirst ? restOf(out.size - outFirst) : ""}`
+                : inOrder || !lastOut
+                    ? `, the last ${out.size} in order`
+                    : !lastOut.said
+                        ? `, the last ${out.size} in order${butLast}`
+                        : lastOutN === 0
+                            ? `, the last ${out.size} ${lastWithout}`
+                            : `: each ${lastWithout}, then the last ${lastOutN} ${lastWhose}`;
+            const elsewhere = place.leftOut ? place.leftOut(out.size, which) : `the other ${out.size} are in structuredContent.data only${which}`;
+            const left = out.size > 0 ? `Only ${kept.length} of the ${n} rows of ${cut.rows} are in it; ${elsewhere}.` : "";
+            // #2899: each row named last that the text still leaves out, by name.
+            const lastLeft = [...out].filter(isLast).sort((a, b) => a - b);
+            const named_ = () => {
+                if (!lastOut?.runs)
+                    return listed(lastLeft.map((i) => String(field(rows[i], lastOut?.name ?? "") ?? `${cut.rows}[${i}]`)));
+                // #3284: by their numbers, in runs, at most OTHERS_LEFT_LISTED parts.
+                const ids = lastLeft.map((i) => field(rows[i], lastOut.name)).map((v, j) => (typeof v === "number" ? v : lastLeft[j])).sort((a, b) => a - b);
+                const r = runsSaid(ids);
+                return `at ${lastOut.name} ${r.said}${r.more > 0 ? `, and ${r.more} more past ${lastOut.name} ${r.last}` : ""}`;
+            };
+            const lastSaid = lastOut && lastLeft.length ? `Of the rows left out of it, ${lastLeft.length} ${lastLeft.length === 1 ? "has" : "have"} ${lastHas}: ${named_()}.` : "";
+            return { text: shown, said: say(...said(outFirst, out), left, lastSaid, cut.whole, out.size > 0 ? cut.page?.(kept.length, n, data) : undefined) };
+        };
         let cutRows = [];
         let beside = data;
         for (const attempt of attempts) {
             const { level } = attempt;
+            beside = attempt.sided ? { ...data, ...sides.fields } : data;
+            sidesSaid = attempt.sided ? sides.said : [];
+            // #3269: before any row is cut to the level outFirstBefore names, the rows leaveOutFirst
+            // names are cut to the leanest level, the others kept at the level before, and then leave,
+            // as many as must. Where even that does not fit, the cut goes on as it did through 3.0.2:
+            // every row at the next level, then rows leaving, those named first.
+            const li = cut.levels.indexOf(level);
+            if (cut.outFirstBefore !== undefined && li === cut.outFirstBefore && li > 0 && named > 0 && attempt === attempts.find((a) => a.level === level)) {
+                const prev = cut.levels[li - 1];
+                const lean = cut.levels[cut.levels.length - 1];
+                const s = { left: new Set(), clipped: 0, capped: 0 };
+                const sn = { left: new Set(), clipped: 0, capped: 0 };
+                // #3269's review: the named rows whose strings the lean level clips, or whose lists it
+                // caps, by index, so the sentence says so of the ones kept (round 1 said only the fields
+                // they leave out, and a clean row's 150-character purl came back clipped unsaid).
+                const clippedAt = new Set();
+                const cappedAt = new Set();
+                const apart = rows.map((r, i) => {
+                    if (!isPlainObject(r))
+                        return cutValue(r, prev.clip, prev.cap ?? Number.POSITIVE_INFINITY, s);
+                    if (!isNamed(i))
+                        return cutRow(r, prev.keep, prev, s);
+                    const [clipped, capped] = [sn.clipped, sn.capped];
+                    const lean_ = cutRow(r, lean.keep, lean, sn);
+                    if (sn.clipped > clipped)
+                        clippedAt.add(i);
+                    if (sn.capped > capped)
+                        cappedAt.add(i);
+                    return lean_;
+                });
+                const extra = [...sn.left].filter((f) => !s.left.has(f));
+                const apartSaid = (left, out) => {
+                    const parts = [];
+                    if (extra.length)
+                        parts.push(`leave out ${listed(extra)} too`);
+                    if ([...clippedAt].some((i) => !out.has(i)))
+                        parts.push(`every string in each of them longer than ${lean.clip} characters keeps its first ${lean.clip}, ending in "…"`);
+                    if (lean.cap !== undefined && [...cappedAt].some((i) => !out.has(i)))
+                        parts.push(`every list in each of them longer than ${lean.cap} entries keeps its first ${lean.cap}`);
+                    return named - left > 0 && parts.length ? `The ${named - left} rows of ${cut.rows} in it whose ${firstOut?.field} is ${(firstOut?.values ?? []).join(" or ")} ${parts.join("; ")}.` : "";
+                };
+                const prevSaid = levelSaid(cut.rows, n, prev, s);
+                const shown = lined({ ...beside, [cut.rows]: apart });
+                if (shown.length <= DATA_TEXT_BUDGET)
+                    return { text: shown, said: say(prevSaid, apartSaid(0, new Set()), ...sidesSaid, cut.whole) };
+                // Only the named rows leave here.
+                const r = leaving(apart, beside, (left, out) => [prevSaid, apartSaid(left, out), ...sidesSaid], named);
+                if (r)
+                    return r;
+            }
             const s = { left: new Set(), clipped: 0, capped: 0 };
             const cap = level.cap ?? Number.POSITIVE_INFINITY;
             cutRows = rows.map((r) => (isPlainObject(r) ? cutRow(r, level.keep, level, s) : cutValue(r, level.clip, cap, s)));
             rowsSaid = levelSaid(cut.rows, n, level, s);
-            beside = attempt.sided ? { ...data, ...sides.fields } : data;
-            sidesSaid = attempt.sided ? sides.said : [];
             const shown = lined({ ...beside, [cut.rows]: cutRows });
             if (shown.length <= DATA_TEXT_BUDGET)
                 return { text: shown, said: say(rowsSaid, ...sidesSaid, cut.whole) };
         }
-        // No level fits: rows leave the text, those the tool names first (by value, in its order,
-        // each from the end), then the rest from the end, until it fits.
-        const lens = cutRows.map((r) => 4 + JSON.stringify(r).length);
-        const emptyLen = lined({ ...beside, [cut.rows]: [] }).length;
-        const textLen = (kept, sum) => (kept === 0 ? emptyLen : emptyLen + 2 + sum + 2 * kept);
-        const firstOut = cut.leaveOutFirst;
-        const order = [];
-        for (const value of firstOut?.values ?? []) {
-            for (let i = n - 1; i >= 0; i--)
-                if (field(rows[i], firstOut?.field ?? "") === value)
-                    order.push(i);
+        // No level fits. #3272: the lists the tool names beforeRows, whole until now, are cut as each
+        // says, one after another in the order named, until the text fits with every row at the
+        // leanest level; then they lose entries, from the end, the last named first, each emptied
+        // before the next loses any (a DataCut's keepAll steps, in the same order); the note says
+        // what each keeps.
+        const spent = (cut.sides ?? []).filter((side) => side.beforeRows);
+        for (const side of spent) {
+            const one = cutSides(data, [side]);
+            if (!one.said.length)
+                continue;
+            beside = { ...beside, ...one.fields };
+            sidesSaid = [...sidesSaid, ...one.said];
+            const shown = lined({ ...beside, [cut.rows]: cutRows });
+            if (shown.length <= DATA_TEXT_BUDGET)
+                return { text: shown, said: say(rowsSaid, ...sidesSaid, cut.whole) };
         }
-        const queued = new Set(order);
-        for (let i = n - 1; i >= 0; i--)
-            if (!queued.has(i))
-                order.push(i);
-        const out = new Set();
-        let sum = lens.reduce((t, x) => t + x, 0);
-        for (const i of order) {
-            if (textLen(n - out.size, sum) <= DATA_TEXT_BUDGET)
+        // 3.1.0's phase A review: the lists named with `capped` have each entry's own list cut to its
+        // first c entries, the most that fit, before any entry of a list leaves (#3272's text emptied
+        // fixed_branches once one package of some 400 ranges did not fit alone, while 3.0.2's every-list
+        // cap kept 32 packages; data caps each package's ranges instead, and so does the text now).
+        const capping = spent.filter((side) => side.capped && Array.isArray(beside[side.list]) && beside[side.list].length > 0);
+        const caps = new Map();
+        const capList = (side, v, c) => v.map((e) => {
+            const inner = isPlainObject(e) ? e[side.capped.list] : undefined;
+            return isPlainObject(e) && Array.isArray(inner) && inner.length > c ? { ...e, [side.capped.list]: inner.slice(0, c), ...side.capped.mark(e, c) } : e;
+        });
+        const longest = (v, list) => v.reduce((m, e) => Math.max(m, Array.isArray(field(e, list)) ? field(e, list).length : 0), 0);
+        // The most c (from `least` up to the longest list less one) at which the text fits, or undefined.
+        const mostCap = (side, whole, with_) => {
+            const at = (c) => lined({ ...with_, [side.list]: capList(side, whole, c), [cut.rows]: cutRows }).length <= DATA_TEXT_BUDGET;
+            let lo = side.capped.least;
+            let hi = longest(whole, side.capped.list) - 1;
+            if (hi < lo || !at(lo))
+                return undefined;
+            while (lo < hi) {
+                const mid = Math.ceil((lo + hi) / 2);
+                if (at(mid))
+                    lo = mid;
+                else
+                    hi = mid - 1;
+            }
+            return lo;
+        };
+        const uncapped = new Map();
+        for (const side of capping) {
+            const whole = beside[side.list];
+            uncapped.set(side.list, whole);
+            const c = mostCap(side, whole, beside) ?? side.capped.least;
+            caps.set(side.list, c);
+            beside = { ...beside, [side.list]: capList(side, whole, c) };
+        }
+        // The sentence for each capped list: c, and the entries whose own list it cut, by name.
+        const capSaid = () => capping.flatMap((side) => {
+            const c = caps.get(side.list);
+            const kept = beside[side.list].length;
+            const inner = (e) => (Array.isArray(field(e, side.capped.list)) ? field(e, side.capped.list).length : 0);
+            const names = uncapped.get(side.list).slice(0, kept).filter((e) => inner(e) > c).map(side.capped.name);
+            return names.length ? [side.capped.said(c, names, place.full === true)] : [];
+        });
+        if (capping.length) {
+            const shown = lined({ ...beside, [cut.rows]: cutRows });
+            if (shown.length <= DATA_TEXT_BUDGET)
+                return { text: shown, said: say(rowsSaid, ...sidesSaid, ...capSaid(), cut.whole) };
+        }
+        const before = [];
+        for (const side of [...spent].reverse()) {
+            const v = beside[side.list];
+            if (!Array.isArray(v) || v.length === 0)
+                continue;
+            const total = Array.isArray(data[side.list]) ? data[side.list].length : v.length;
+            const at = (k) => lined({ ...beside, [side.list]: v.slice(0, k), [cut.rows]: cutRows }).length;
+            // Every entry of it does not fit (the text did not, as it stands): the most that do, or none.
+            let k = 0;
+            if (at(0) <= DATA_TEXT_BUDGET) {
+                let hi = v.length - 1;
+                while (k < hi) {
+                    const mid = Math.ceil((k + hi) / 2);
+                    if (at(mid) <= DATA_TEXT_BUDGET)
+                        k = mid;
+                    else
+                        hi = mid - 1;
+                }
+            }
+            beside = { ...beside, [side.list]: v.slice(0, k) };
+            before.push(k === 0 ? `${side.list} keeps none of its ${total} entries` : `${side.list} keeps its first ${k} of ${total} entries`);
+            if (at(k) <= DATA_TEXT_BUDGET)
                 break;
-            out.add(i);
-            sum -= lens[i];
         }
-        const kept = cutRows.filter((_, i) => !out.has(i));
-        const shown = lined({ ...beside, [cut.rows]: kept });
-        if (kept.length > 0 && shown.length <= DATA_TEXT_BUDGET) {
-            const outFirst = firstOut ? [...out].filter((i) => firstOut.values.includes(String(field(rows[i], firstOut.field)))).length : 0;
-            const which = outFirst > 0
-                ? `: the ${outFirst} whose ${firstOut?.field} is ${(firstOut?.values ?? []).join(" or ")} (${firstOut?.why})${out.size > outFirst ? `, and the last ${out.size - outFirst} of the rest` : ""}`
-                : `, the last ${out.size} in order`;
-            const elsewhere = place.leftOut ? place.leftOut(out.size, which) : `the other ${out.size} are in structuredContent.data only${which}`;
-            const left = `Only ${kept.length} of the ${n} rows of ${cut.rows} are in it; ${elsewhere}.`;
-            return { text: shown, said: say(rowsSaid, ...sidesSaid, left, cut.whole, cut.page?.(kept.length, n, data)) };
+        // The room the entries that left give back goes to the capped lists' c (as the structured cut's
+        // giveBack does), the first named first.
+        for (const side of capping) {
+            const whole = uncapped.get(side.list);
+            const kept = beside[side.list].length;
+            const c = mostCap(side, whole.slice(0, kept), beside);
+            if (c !== undefined && c > caps.get(side.list)) {
+                caps.set(side.list, c);
+                beside = { ...beside, [side.list]: capList(side, whole.slice(0, kept), c) };
+            }
+        }
+        if (before.length || capping.length) {
+            if (before.length)
+                sidesSaid = [...sidesSaid, `In it, ${listed(before)}, before any row of ${cut.rows} is left out.`];
+            sidesSaid = [...sidesSaid, ...capSaid()];
+            const shown = lined({ ...beside, [cut.rows]: cutRows });
+            if (shown.length <= DATA_TEXT_BUDGET)
+                return { text: shown, said: say(rowsSaid, ...sidesSaid, cut.whole) };
         }
+        // Then rows leave the text, those the tool names first, then the rest from the end, until it
+        // fits (#2899: those it names last only once every other row is out).
+        const r = leaving(cutRows, beside, () => [rowsSaid, ...sidesSaid]);
+        if (r)
+            return r;
         base = { ...beside, [cut.rows]: cutRows };
     }
     // Step 4: lists, then strings.
@@ -336,19 +590,71 @@ export const answeringNow = () => calls.getStore();
 // tool and directs no model (test/description-policy.test.mjs reads inputSchema descriptions too).
 export const FULL_ARG_DESCRIPTION = "true: data in the structured result is the answer whole, however long. Without it, a structured result past 30,000 characters of JSON has its data cut (DATA CUT): in an order the note states, the entries of its longest lists keep only some of their fields, and then the lists only some of their entries; data_truncated is true, and truncated gives each list cut with its total, the number returned and whether its entries are thinned. Whole data is for a program; a client that sizes structured results, as Claude Code does against MAX_MCP_OUTPUT_TOKENS, can refuse an answer past its cap.";
 export const FULL_ARG = z.boolean().optional().describe(FULL_ARG_DESCRIPTION);
-const thinned = (e, keep) => isPlainObject(e) ? cutRow(e, keep, { keep, clip: Number.POSITIVE_INFINITY }, { left: new Set(), clipped: 0, capped: 0 }) : e;
+// A level as its fields, and what it does inside each entry (#3132).
+const levelOf = (l) => (Array.isArray(l) ? { keep: l } : l);
+// The cap an entry is cut to at a level: `cap`, or the entry's floor where that is more (#3269's
+// second review: EntryLevel.floor), unless `below` (leaveAt's floor, for the one entry kept).
+const capFor = (lv, e, cap, below) => (lv.floor && !below ? Math.max(cap, lv.floor(e)) : cap);
+const thinned = (e, level, cap = Number.POSITIVE_INFINITY, below) => {
+    if (!isPlainObject(e))
+        return e;
+    const lv = levelOf(level);
+    const { keep, capped, mark, pick } = lv;
+    const c = capFor(lv, e, cap, below);
+    const t = cutRow(e, keep, { keep, clip: Number.POSITIVE_INFINITY });
+    const inner = capped ? t[capped] : undefined;
+    if (capped && Array.isArray(inner) && inner.length > c) {
+        // cutRow keeps every entry of the list, in order, so inner[j] is the thinned e[capped][j].
+        const whole = e[capped];
+        t[capped] = pick && Array.isArray(whole) && whole.length === inner.length ? pick(whole, c).map((j) => inner[j]) : inner.slice(0, c);
+    }
+    return mark ? { ...t, ...mark(e, c) } : t;
+};
+const innerOf = (e, capped) => (capped !== undefined && Array.isArray(field(e, capped)) ? field(e, capped).length : 0);
+// The longest list named `capped` inside any entry of a list (#3132): the cap a level starts below.
+const longestInside = (v, capped) => Array.isArray(v) ? v.reduce((m, e) => Math.max(m, Array.isArray(field(e, capped)) ? field(e, capped).length : 0), 0) : 0;
 // An entry JSON cannot write (undefined) is written null in a list.
 const entryChars = (e) => JSON.stringify(e)?.length ?? 4;
 const listOf = (data, at) => at.reduce((o, k) => field(o, k), data);
-function listAt(data, path, firstOut, thin, newest) {
+// 3.0.2: a list's entries are measured, thinned, only when the cut first asks how many characters
+// some of them take (chars), each thinned, measured and let go; and thinned to be kept only when
+// the cut asks for them (keep), only those it keeps, each once. Through 3.0.1 every list the cut
+// tried held every entry thinned for as long as the cut ran, and a level that caps a list inside
+// each entry thinned every entry at no cap before it tried any: on a 2,000-row check_sbom answer
+// (test/http-memory.test.mjs's) the structured cut allocated 108 MB, against 18 MB on 3.0.0 and 24
+// MB now (V8's sampling heap profiler, collected objects included). What is measured and kept is
+// the same: each entry thinned as before, its characters summed as before.
+// #3269: with `outLevel`, the entries firstOut names are cut to it instead (DataCutStep.outFirst).
+// #3269's second review: with `last`, the entries not named that it holds leave after those it does
+// not (DataCutStep.leaveLast); with `below`, each entry is cut to `cap` under its floor.
+function listAt(data, path, firstOut, level, newest, cap = Number.POSITIVE_INFINITY, levelAt, outLevel, last, below, ordered, shared) {
     const at = path.split(".");
     const v = listOf(data, at);
     if (!Array.isArray(v) || v.length === 0)
         return undefined;
     const n = v.length;
-    const entries = thin ? v.map((e) => thinned(e, thin)) : v;
-    const lens = entries.map(entryChars);
-    // The indices in the order they leave: from the end, or, for a series kept newest, from the start.
+    const isNamed = (i) => firstOut !== undefined && firstOut.values.includes(field(v[i], firstOut.field));
+    const cutOne = (i) => (outLevel && isNamed(i) ? thinned(v[i], outLevel) : level ? thinned(v[i], level, cap, below) : v[i]);
+    const cache = shared ?? { made: [] };
+    const made = cache.made;
+    const entry = (i) => {
+        if (!level && !outLevel)
+            return v[i];
+        if (!(i in made))
+            made[i] = cutOne(i);
+        return made[i];
+    };
+    const thin = level ? levelOf(level).keep : undefined;
+    // A capped level's clause only where its cap cuts an entry's list (#3139's review: a package
+    // with one range is not "at most its first 1"), each entry at its own floor or more (#3269's
+    // second review), and told whether some entry's floor is above the cap.
+    const lv = level ? levelOf(level) : undefined;
+    const bites = lv?.capped === undefined || v.some((e) => innerOf(e, lv.capped) > capFor(lv, e, cap, below));
+    const raised = lv?.capped !== undefined && lv.floor !== undefined && !below && v.some((e) => innerOf(e, lv.capped) > cap && lv.floor(e) > cap);
+    const thinSaid = lv && bites ? (below ? (lv.below ?? lv.said)?.(cap) : lv.said?.(cap, raised)) : undefined;
+    // The indices in the order they leave: from the end, or, for a series kept newest, from the start;
+    // those firstOut names first, value by value; then, with `last`, the others it does not hold,
+    // then those it holds.
     const leavingOrder = (i) => (newest ? i : n - 1 - i);
     const order = [];
     for (const value of firstOut?.values ?? [])
@@ -357,27 +663,73 @@ function listAt(data, path, firstOut, thin, newest) {
                 order.push(leavingOrder(j));
     const named = order.length;
     const queued = new Set(order);
-    for (let j = 0; j < n; j++)
-        if (!queued.has(leavingOrder(j)))
-            order.push(leavingOrder(j));
-    const leaving = [0];
-    for (const i of order)
-        leaving.push(leaving[leaving.length - 1] + lens[i]);
-    const all = leaving[n];
+    const held = (i) => last !== undefined && last.has(v[i]);
+    for (const late of last ? [false, true] : [false])
+        for (let j = 0; j < n; j++)
+            if (!queued.has(leavingOrder(j)) && (!last || held(leavingOrder(j)) === late))
+                order.push(leavingOrder(j));
+    // #3269's second review: an order the cut chose (the rows kept by fit, cutData), named first.
+    if (ordered && ordered.length === n)
+        order.splice(0, n, ...ordered);
+    // The characters of the entries in the order they leave, summed: leaving[j] is the first j's.
+    let leaving;
+    const lensOf = () => {
+        if (cache.lens)
+            return cache.lens;
+        const lens = [];
+        for (let i = 0; i < n; i++)
+            lens.push(entryChars(i in made ? made[i] : cutOne(i)));
+        cache.lens = lens;
+        return lens;
+    };
+    const sums = () => {
+        if (leaving)
+            return leaving;
+        const ls = lensOf();
+        leaving = [0];
+        for (const i of order)
+            leaving.push(leaving[leaving.length - 1] + ls[i]);
+        return leaving;
+    };
     const kept = (k) => Math.max(0, Math.min(n, k));
+    const over = new Map();
+    const keptAt = (k) => {
+        const out = new Set(order.slice(0, n - kept(k)));
+        return Array.from({ length: n }, (_, i) => i).filter((i) => !out.has(i));
+    };
     return {
         path,
         at,
         n,
         firstOut,
         thin,
+        ...(thinSaid ? { thinSaid } : {}),
         ...(newest ? { newest } : {}),
         named,
-        chars: (k) => all - leaving[n - kept(k)] + Math.max(0, kept(k) - 1),
-        keep: (k) => {
-            const out = new Set(order.slice(0, n - kept(k)));
-            return entries.filter((_, i) => !out.has(i));
+        ...(levelAt !== undefined ? { level: levelAt } : {}),
+        cap,
+        over,
+        ...(outLevel && named > 0 ? { outThin: levelOf(outLevel).keep } : {}),
+        isNamed,
+        ...(last ? { leaveLast: last } : {}),
+        othersOut: (k) => {
+            const out = order.slice(0, n - kept(k)).filter((i) => !isNamed(i));
+            const own = (i) => (last ? field(v[i], last.id) : undefined);
+            const byPosition = out.some((i) => typeof own(i) !== "number" || !Number.isFinite(own(i)));
+            const id = (i) => (byPosition ? i + 1 : own(i));
+            const asc = (xs) => xs.sort((a, b) => id(a) - id(b));
+            return { held: asc(out.filter(held)), rest: asc(out.filter((i) => !held(i))), id, byPosition };
+        },
+        ...(below ? { below } : {}),
+        order,
+        charsOf: (i) => lensOf()[i],
+        withOrder: (o) => listAt(data, path, firstOut, level, newest, cap, levelAt, outLevel, last, below, o, cache),
+        chars: (k) => {
+            const l = sums();
+            return l[n] - l[n - kept(k)] + Math.max(0, kept(k) - 1);
         },
+        kept: keptAt,
+        keep: (k) => keptAt(k).map((i) => (over.has(i) ? over.get(i)?.entry : entry(i))),
     };
 }
 // `o` with the list at `at` replaced by `v`, each object on the way copied, its keys in their order.
@@ -388,14 +740,97 @@ function withList(o, at, v) {
 const orListed = (xs) => (xs.length < 2 ? xs.join("") : `${xs.slice(0, -1).join(", ")} or ${xs[xs.length - 1]}`);
 // The fields a thinning level keeps, as a sentence says them.
 const keepSaid = (keep) => listed(keep.map((x) => (typeof x === "string" ? x : `${x[0]} (each with ${listed([...x[1]])})`)));
+// The clause on the entries that took back detail (#3132's review): their positions among those
+// kept, in their order in data, grouped where one level and cap holds a run of them (#3132's second
+// review: not always the first kept, since give-back passes an entry that cannot take any back).
+function givenBackSaid(list, k) {
+    if (list.over.size === 0)
+        return "";
+    const kept = list.kept(k);
+    const runs = [];
+    kept.forEach((i, pos) => {
+        const g = list.over.get(i);
+        if (!g)
+            return;
+        const last = runs[runs.length - 1];
+        if (last && last.to === pos && last.g.level === g.level && last.g.cap === g.cap)
+            last.to = pos + 1;
+        else
+            runs.push({ from: pos + 1, to: pos + 1, g });
+    });
+    if (runs.length === 0)
+        return "";
+    const n = runs.reduce((t, r) => t + r.to - r.from + 1, 0);
+    const one = (r) => `${r.from === r.to ? `entry ${r.from}` : `entries ${r.from} to ${r.to}`} cut to ${keepSaid(r.g.keep)}${r.g.said ? `, ${r.g.said}` : ""}`;
+    return `; with the room left, ${n} of the entries kept take back detail (by position among those kept, in their order in data): ${runs.map(one).join("; ")}`;
+}
+// The most ids, or runs of them, the clause on the entries not named that left lists (#3269's
+// second review): a client calls those again a few calls' worth at a time (workload_triage: at
+// most 5 calls), and past this many it says how many more. #3269's third review: those LeaveLast
+// holds and the others share it, the held ones first.
+export const OTHERS_LEFT_LISTED = 100;
+// Integers, ascending, as a sentence names them, runs of three or more as "a to b", at most `max`
+// parts: the parts, how many integers they say (`n`) and leave out (`more`), and the last said.
+const runsSaid = (xs, max = OTHERS_LEFT_LISTED) => {
+    const parts = [];
+    // xs[0..j) are said.
+    let j = 0;
+    while (j < xs.length && parts.length < max) {
+        let e = j;
+        while (e + 1 < xs.length && xs[e + 1] === xs[e] + 1)
+            e++;
+        if (e - j >= 2) {
+            parts.push(`${xs[j]} to ${xs[e]}`);
+            j = e + 1;
+        }
+        else {
+            parts.push(String(xs[j]));
+            j++;
+        }
+    }
+    return { said: listed(parts), parts: parts.length, n: j, more: xs.length - j, last: xs[j - 1] };
+};
+// The clause on the `g` entries not named that left, with LeaveLast: how many, the order they are
+// kept in, and which (by its id), those LeaveLast holds first and apart (#3269's third review);
+// and, where LeaveLast.again gives it, the sentence on checking them again: in that order, in calls
+// of the sizes PageAt.againFit gives.
+// With `counted` false the clause leaves out the count (the sentence has just said it). The order
+// they were kept in is said where it shows (some entry kept after one that left, in input order).
+function othersLeftSaid(list, k, g, fit, counted = true) {
+    const ll = list.leaveLast;
+    const { held, rest, id, byPosition } = list.othersOut(k);
+    const by = byPosition ? `position in ${list.path} (from 1)` : ll.id;
+    const h = runsSaid(held.map(id));
+    const r = runsSaid(rest.map(id), OTHERS_LEFT_LISTED - h.parts);
+    const at = (x) => x.n === 0 ? `not named here (the note names at most ${OTHERS_LEFT_LISTED} of them, or runs of them)` : `at ${by} ${x.said}${x.more > 0 ? `, and ${x.more} more past ${by} ${x.last}` : ""}`;
+    const which = held.length === 0
+        ? `, ${g === 1 ? "without" : "none with"} ${ll.said}, ${at(r)}`
+        : rest.length === 0
+            ? `, ${g === 1 ? "with" : "all with"} ${ll.said}, ${at(h)}`
+            : `: the ${held.length === 1 ? "one" : held.length} with ${ll.said} ${at(h)}; the other ${rest.length} ${at(r)}`;
+    // Where none of them is one LeaveLast holds and each left after every entry kept (the last
+    // ones), the order shows nothing to say (the synthetic's 201-purl probe: 43 rows kept with it
+    // unsaid, 42 with it said).
+    const kept = list.kept(k).filter((i) => !list.isNamed(i));
+    const last = held.length === 0 && (kept.length === 0 || rest.every((i) => i > kept[kept.length - 1]));
+    const said = `${counted ? `${g} ` : ""}${g === 1 ? ll.rest[0] : ll.rest[1]}${which}${last ? "" : ` (${ll.chosen})`}`;
+    if (!ll.again || byPosition)
+        return { said, again: "" };
+    // The entries the note names, in the order it names them.
+    const seq = [...held.slice(0, h.n), ...rest.slice(0, r.n)];
+    const { sizes, m, alone } = fit.againFit(list.path, seq);
+    const a = runsSaid(alone.map(id), Number.POSITIVE_INFINITY);
+    return { said, again: ll.again({ k: seq.length, sizes, m, alone: a.said, aloneCount: alone.length }) };
+}
 // What a cut keeps of each list it has cut so far, as truncated and as the DATA CUT sentences.
-function cutSaid(cut, kept, wholeChars, data, over, wholeFit) {
+function cutSaid(cut, kept, wholeChars, data, over, fit) {
     const isThinned = ({ list, k }) => list.thin !== undefined && k > 0;
     const cutOnes = kept.filter((x) => x.k < x.list.n || isThinned(x));
     if (cutOnes.length === 0)
         return { said: "" };
     const truncated = Object.fromEntries(cutOnes.map((x) => [x.list.path, { total: x.list.n, returned: x.k, ...(isThinned(x) ? { thinned: true } : {}) }]));
     const parts = [];
+    const again = [];
     const byKept = new Map();
     for (const x of cutOnes) {
         const { list, k } = x;
@@ -403,9 +838,29 @@ function cutSaid(cut, kept, wholeChars, data, over, wholeFit) {
         const first = Math.min(out, list.named);
         const end = list.newest ? "oldest" : "last";
         const which = list.firstOut ? `whose ${list.firstOut.field} is ${orListed(list.firstOut.values)} (${list.firstOut.why})` : "";
-        const leftOut = out === 0 ? "" : first === 0 ? `, the ${end} ${out} left out` : first === out ? `, the ${out} left out being entries ${which}` : `, the ${out} left out being the ${first} ${which} and the ${end} ${out - first} of the rest`;
+        // #3269's second review: with LeaveLast, the entries not named that left are named by its id,
+        // so a client can call them alone again, and the order they leave in is said. #3269's third
+        // review: and how many of them, in the order named, a call of them alone keeps every one of.
+        const others = list.leaveLast && out > first ? othersLeftSaid(list, k, out - first, fit, first > 0) : undefined;
+        const rest = others?.said ?? "";
+        if (others?.again)
+            again.push(others.again);
+        const leftOut = out === 0
+            ? ""
+            : rest
+                ? first === 0
+                    ? `, the ${out} left out being ${rest}`
+                    : `, the ${out} left out being the ${first} ${which} and ${rest}`
+                : first === 0
+                    ? `, the ${end} ${out} left out`
+                    : first === out
+                        ? `, the ${out} left out being entries ${which}`
+                        : `, the ${out} left out being the ${first} ${which} and the ${end} ${out - first} of the rest`;
         if (isThinned(x)) {
-            parts.push(`${list.path} keeps ${k === list.n ? `all ${k}` : `${k} of its ${list.n}`} entries, each cut to ${keepSaid(list.thin)}${leftOut}`);
+            // #3269: the entries outFirst cut apart, those of them kept.
+            const apart = list.outThin ? list.kept(k).filter((i) => list.isNamed(i)).length : 0;
+            const apartSaid = apart > 0 && list.firstOut ? `, except the ${apart} kept whose ${list.firstOut.field} is ${orListed(list.firstOut.values)}, each cut to ${keepSaid(list.outThin)}` : "";
+            parts.push(`${list.path} keeps ${k === list.n ? `all ${k}` : `${k} of its ${list.n}`} entries, each cut to ${keepSaid(list.thin)}${list.thinSaid ? `, ${list.thinSaid}` : ""}${apartSaid}${leftOut}${givenBackSaid(list, k)}`);
             continue;
         }
         if (!list.firstOut || first === 0 || k === 0) {
@@ -433,9 +888,10 @@ function cutSaid(cut, kept, wholeChars, data, over, wholeFit) {
         return p.k === 0 ? `${paths} keep none of their entries` : `${paths} keep their ${which} ${p.k} entries each`;
     });
     const keeps = Object.fromEntries(cutOnes.filter(isThinned).map((x) => [x.list.path, x.list.thin]));
-    const page = cut.page?.(truncated, data, { keeps, wholeFit }) ?? "";
+    const page = cut.page?.(truncated, data, { keeps, ...fit }) ?? "";
     const said = [
         `DATA CUT: with data whole, this structured result is ${wholeChars} characters of JSON, more than the ${STRUCTURED_BUDGET} it holds unless the call says full: true, so its data is cut: ${cuts.join("; ")}.`,
+        ...again,
         "truncated gives the total and the number returned of each list cut, and thinned where its entries are cut to some of their fields.",
         page,
         over ? `Cut so, the structured result is still past ${STRUCTURED_BUDGET} characters: data holds no other list to cut.` : "",
@@ -456,6 +912,8 @@ export function cutData(data, cut, wholeChars, structured) {
     const steps = [...cut.steps, { lists: Object.keys(data).filter((k) => !named.has(k)) }];
     // Each list cut so far, in the order cut, at the level it was thinned to, how many entries it
     // keeps, and the step that cut it.
+    // `gone` (#3269): the list's entries outFirst names left before the others were cut further, and
+    // may come back once the cut is settled.
     const kept = new Map();
     const apply = (also = []) => [...kept.values(), ...also].reduce((d, { list, k }) => withList(d, list.at, list.keep(k)), data);
     // PageAt.wholeFit: of the list at `path`, the most first entries, each whole, that the result
@@ -481,27 +939,378 @@ export function cutData(data, cut, wholeChars, structured) {
         wholeFits.set(path, k);
         return k;
     };
+    // PageAt.firstFit (#3269's review): of the list at `path`, which a step thins, the most first
+    // entries n such that, for every n' up to n, a call answering only the first n' of them keeps
+    // every one of them, as this cut would cut that call: it does where
+    //   - every entry fits thinned (thin[0]), those leaveOutFirst names cut to outFirst's level; or
+    //   - every entry fits at the floor (thin[floor.at] at its least, each entry at its own
+    //     EntryLevel.floor or more: #3269's second review), those named so cut, and either none is
+    //     named or the entries not named, thinned, are past the budget on their own (so the call
+    //     cannot keep them uncapped by sending the named ones out, and keeps them at the floor
+    //     instead).
+    // A step without a floor is held to its leaveAt level and cap instead, so a page of that size
+    // comes back with that level's detail, as #3132's review asked. Each size is counted as this
+    // call's: the entries as they are (the first n of a call are these, at the same index), data
+    // beside them with this list and the lists of the steps before it empty (a cut empties those
+    // first, and a call of fewer purls sends them all), and this call's envelope and note, with the
+    // longest DATA CUT sentence such a call can carry while it keeps every entry. A call of fewer
+    // purls has a note no longer than this one's (its counts are no larger, the affected components
+    // it names are the first of these), but for its TEXT CUT sentences, which can be cut no further
+    // than this call's text but can take another form: FIRST_FIT_SLACK holds the difference.
+    const FIRST_FIT_SLACK = 600;
+    const measures = new Map();
+    const measureOf = (path) => {
+        const known = measures.get(path);
+        if (known !== undefined)
+            return known;
+        const s = steps.findIndex((st) => st.lists.includes(path));
+        const v = listOf(data, path.split("."));
+        const m = s >= 0 && steps[s].thin?.length && Array.isArray(v) && v.length > 0 ? measureFor(steps[s], s, path, v) : null;
+        measures.set(path, m);
+        return m;
+    };
+    const measureFor = (step, s, path, v) => {
+        const thin = step.thin;
+        const first = step.leaveOutFirst;
+        const out = first ? step.outFirst : undefined;
+        const floor = out?.floor;
+        const lean = out?.level;
+        const n = v.length;
+        const isNamed = (e) => first !== undefined && first.values.includes(field(e, first.field));
+        const bare = [path, ...steps.slice(0, s).flatMap((st) => st.lists)].reduce((d, p) => (Array.isArray(listOf(d, p.split("."))) ? withList(d, p.split("."), []) : d), data);
+        const base = JSON.stringify(bare).length;
+        // The level and cap every entry is held to where they are not all kept thinned.
+        const atFloor = floor ? floor.at : step.leaveAt ? step.leaveAt.level : thin.length - 1;
+        const floorCap = floor ? (levelOf(thin[atFloor]).least ?? 0) : step.leaveAt ? step.leaveAt.cap : Number.POSITIVE_INFINITY;
+        // The envelope, its note and the longest DATA CUT sentence of a call that keeps every entry,
+        // at each level it can stop at (a capped level's clause said at its least, where it bites).
+        const noPage = { steps: cut.steps };
+        const stops = [0, ...(floor && out ? Array.from({ length: floor.at - out.before + 1 }, (_, j) => out.before + j) : [atFloor])];
+        const env = Math.max(...stops.map((j) => {
+            const lv = levelOf(thin[j]);
+            const list = listAt(data, path, first, thin[j], step.keepNewest, lv.capped ? (lv.least ?? 0) : Number.POSITIVE_INFINITY, j, lean, step.leaveLast);
+            if (!list)
+                return 0;
+            const { said } = cutSaid(noPage, [{ list, k: n }], wholeChars, data, false, { wholeFit, firstFit: () => 0, againFit: () => ({ sizes: [], m: 0, alone: [] }) });
+            return JSON.stringify(structured(null, { [path]: { total: n, returned: n, thinned: true } }, said)).length - "null".length;
+        })) +
+            base +
+            FIRST_FIT_SLACK;
+        const chars = (e, level, cap = Number.POSITIVE_INFINITY) => entryChars(thinned(e, level, cap));
+        const once = (f) => {
+            const got = new Map();
+            return (i) => {
+                let c = got.get(i);
+                if (c === undefined)
+                    got.set(i, (c = f(i)));
+                return c;
+            };
+        };
+        const named = (i) => isNamed(v[i]);
+        return {
+            v,
+            step,
+            env,
+            named,
+            thinChars: once((i) => chars(v[i], named(i) && lean !== undefined ? lean : thin[0])),
+            floorChars: once((i) => (named(i) && lean !== undefined ? chars(v[i], lean) : chars(v[i], thin[atFloor], floorCap))),
+        };
+    };
+    const firstFits = new Map();
+    const firstFit = (path) => {
+        const known = firstFits.get(path);
+        if (known !== undefined)
+            return known;
+        const ms = measureOf(path);
+        const fit = ms ? firstFitOf(ms) : 0;
+        firstFits.set(path, fit);
+        return fit;
+    };
+    const firstFitOf = ({ v, step, env, named: isNamed, thinChars, floorChars }) => {
+        const out = step.leaveOutFirst ? step.outFirst : undefined;
+        const floor = out?.floor;
+        const n = v.length;
+        let thinnedAll = 0;
+        let atFloorAll = 0;
+        let others = 0;
+        let othersAlone = 0;
+        let named = 0;
+        for (let i = 0; i < n; i++) {
+            const nm = isNamed(i);
+            if (nm)
+                named++;
+            thinnedAll += thinChars(i);
+            atFloorAll += floorChars(i);
+            if (!nm) {
+                others++;
+                othersAlone += thinChars(i);
+            }
+            const commas = i;
+            const keepsThinned = env + thinnedAll + commas <= STRUCTURED_BUDGET;
+            const keepsAtFloor = env + atFloorAll + commas <= STRUCTURED_BUDGET;
+            // The entries not named, thinned, without the rest of the result: a lower bound.
+            const othersPast = othersAlone + Math.max(0, others - 1) + 2 > STRUCTURED_BUDGET;
+            if (!(keepsThinned || (keepsAtFloor && (named === 0 || !out || (floor !== undefined && othersPast)))))
+                return i;
+        }
+        return n;
+    };
+    // PageAt.againFit (#3269's third review): of the entries `seq` names (none of them one
+    // leaveOutFirst names, so a call of them alone keeps every one where they fit at their floor, as
+    // firstFit counts), those that do not fit at it even alone leave `seq` (`alone`). Of the rest,
+    // each of the first LeaveLast.againCalls calls takes the most of those left, in order, that fit
+    // at the floor beside the result's envelope (this call's, its note with LeaveLast.noteOver's
+    // characters for a call of that many, and a DATA CUT sentence keeping them all); of the entries
+    // after those, m is the most such that every m of them in a row fit so. So each call of those
+    // sizes keeps every one, and so does a call of fewer of them in a row. Counted once per `seq`
+    // (the cut sizes the same note many times).
+    const againFits = new Map();
+    const againFit = (path, seq) => {
+        const key = `${path}:${seq.join(",")}`;
+        const known = againFits.get(key);
+        if (known)
+            return known;
+        const got = againFitOf(path, seq);
+        againFits.set(key, got);
+        return got;
+    };
+    const againFitOf = (path, seq) => {
+        const ms = measureOf(path);
+        if (!ms || seq.length === 0)
+            return { sizes: [], m: 0, alone: [] };
+        const ll = ms.step.leaveLast;
+        const over = ll?.noteOver?.(seq.map((i) => ms.v[i]), ms.v) ?? (() => 0);
+        const room = (m) => STRUCTURED_BUDGET - ms.env - over(m);
+        const one = room(1);
+        const alone = seq.filter((i) => ms.floorChars(i) > one);
+        const rest = alone.length ? seq.filter((i) => ms.floorChars(i) <= one) : seq;
+        const calls = ll?.againCalls ?? 0;
+        // sums[j]: the characters of rest's first j entries; rest[a..b) fits as one call.
+        const sums = [0];
+        for (const i of rest)
+            sums.push(sums[sums.length - 1] + ms.floorChars(i));
+        const fitsAt = (a, b) => sums[b] - sums[a] + (b - a - 1) <= room(b - a);
+        const sizes = [];
+        let at = 0;
+        while (sizes.length < calls && at < rest.length) {
+            let b = at + 1;
+            while (b < rest.length && fitsAt(at, b + 1))
+                b++;
+            sizes.push(b - at);
+            at = b;
+        }
+        // Every m of rest[at..] in a row fits (fewer, at its end, are within the last m).
+        const fits = (m) => {
+            for (let a = at; a + m <= rest.length; a++)
+                if (!fitsAt(a, a + m))
+                    return false;
+            return true;
+        };
+        let m = rest.length > at ? 1 : 0;
+        let hi = rest.length - at;
+        while (m < hi) {
+            const mid = Math.ceil((m + hi) / 2);
+            if (fits(mid))
+                m = mid;
+            else
+                hi = mid - 1;
+        }
+        return { sizes, m, alone };
+    };
+    const fit = { wholeFit, firstFit, againFit };
     // The result's size with this step's lists at k entries each: the rest of the result (data
     // null), data with this step's lists empty (`base`), and their entries.
     const size = (lists, k, base) => {
         const all = [...kept.values(), ...lists.map((list) => ({ list, k: Math.min(k, list.n) }))];
-        const { truncated, said } = cutSaid(cut, all, wholeChars, data, false, wholeFit);
+        const { truncated, said } = cutSaid(cut, all, wholeChars, data, false, fit);
         return JSON.stringify(structured(null, truncated, said)).length - "null".length + base + lists.reduce((t, l) => t + l.chars(k), 0);
     };
+    // #3269's second review: whether an entry of a step's lists that leaveOutFirst does not name holds
+    // any entry of the list leaveAt's level caps (DataCutStep.leaveAt's floor).
+    const holdsInner = (step) => {
+        const inner = step.thin && step.leaveAt ? levelOf(step.thin[step.leaveAt.level]).capped : undefined;
+        if (inner === undefined)
+            return false;
+        const first = step.leaveOutFirst;
+        const named = (e) => first !== undefined && first.values.includes(field(e, first.field));
+        return step.lists.some((p) => {
+            const v = listOf(data, p.split("."));
+            return Array.isArray(v) && v.some((e) => !named(e) && innerOf(e, inner) > 0);
+        });
+    };
+    // #3269's second review: with leaveAt's floor and LeaveLast, the entries kept are chosen in the
+    // reverse of the order they leave in (LeaveLast's first, then the rest, each from the start),
+    // each one kept that fits beside those chosen before it, and the rest leave first: the list so
+    // reordered, and how many it keeps. In the plain order a row too large to fit beside the rows kept
+    // sent every row before it in that order out with it, and left their room empty: a row of 200
+    // KEV-listed matches after 150 purls of an image (40 affected) kept 1 row of 151, in 7,572
+    // characters. The choice is made on the room the result leaves with none kept, then checked as
+    // the result is (its note names the entries left out, by index), the last chosen leaving while it
+    // does not fit, and topped up, each entry not chosen that fits now, in the same order.
+    const keptByFit = (l, base) => {
+        if (size([l], 0, base) > STRUCTURED_BUDGET)
+            return undefined;
+        const named = l.order.filter((i) => l.isNamed(i));
+        const pri = [...l.order].reverse().filter((i) => !l.isNamed(i));
+        const orderOf = (chosen) => [...named, ...l.order.filter((i) => !l.isNamed(i) && !chosen.has(i)), ...l.order.filter((i) => chosen.has(i))];
+        const chosen = new Set();
+        let room = STRUCTURED_BUDGET - size([l], 0, base);
+        for (const i of pri) {
+            const c = l.charsOf(i) + (chosen.size > 0 ? 1 : 0);
+            if (c > room)
+                continue;
+            chosen.add(i);
+            room -= c;
+        }
+        let cur = l.withOrder(orderOf(chosen));
+        let k = chosen.size;
+        while (k > 0 && size([cur], k, base) > STRUCTURED_BUDGET)
+            k--;
+        for (let tries = 0; tries < 64; tries++) {
+            const kept = new Set(cur.kept(k));
+            const left = STRUCTURED_BUDGET - size([cur], k, base);
+            const next = pri.find((i) => !kept.has(i) && cur.charsOf(i) + 1 <= left && size([cur.withOrder(orderOf(new Set([...kept, i])))], k + 1, base) <= STRUCTURED_BUDGET);
+            if (next === undefined)
+                break;
+            cur = cur.withOrder(orderOf(new Set([...kept, next])));
+            k++;
+        }
+        return { list: cur, k };
+    };
     let fits = false;
     for (const [s, step] of steps.entries()) {
         // Every entry whole, then each thinning level in turn, every entry kept; at the leanest level
-        // the entries leave until the result fits.
+        // the entries leave until the result fits (with keepAll, #3139, not in this step: see below).
         const levels = [undefined, ...(step.thin ?? [])];
         let lists = [];
         let k = 0;
+        // #3269: once the entries outFirst names have left (gone), each later level cuts them to its
+        // level, so that they can come back so cut, and keeps at most the others (they leave first).
+        const out = step.leaveOutFirst ? step.outFirst : undefined;
+        let gone = false;
+        const at = (level, cap, levelAt, outLevel = gone ? out?.level : undefined, below) => step.lists
+            .map((p) => listAt(data, p, step.leaveOutFirst, level, step.keepNewest, cap, levelAt, outLevel, step.leaveLast, below))
+            .filter((l) => l !== undefined && !kept.has(l.path));
+        // #3269's second review: with leaveAt's floor, the last level tried with every entry kept is
+        // leaveAt's while an entry not named holds inner entries (DataCutStep.leaveAt): no later level
+        // keeps any of them, so the entries leave there, whole, instead.
+        const end = step.leaveAt?.floor && step.thin && holdsInner(step) ? step.leaveAt.level + 1 : levels.length - 1;
         for (const [i, thin] of levels.entries()) {
-            lists = step.lists.map((p) => listAt(data, p, step.leaveOutFirst, thin, step.keepNewest)).filter((l) => l !== undefined && !kept.has(l.path));
+            if (i > end)
+                break;
+            // #3269: before any entry is cut to thin[out.before], the entries leaveOutFirst names are cut
+            // to out.level, the others kept at the level before; then they leave, as many as must.
+            if (out && !gone && i === out.before + 1) {
+                const apart = at(levels[i - 1], undefined, i - 2, out.level);
+                if (apart.some((l) => l.named > 0)) {
+                    const base = JSON.stringify(apply(apart.map((list) => ({ list, k: 0 })))).length;
+                    const rest = Math.max(...apart.map((l) => l.n - l.named));
+                    const all = Math.max(...apart.map((l) => l.n));
+                    // The most entries each list keeps, `lo` at least, cut as `ls` is.
+                    const most = (ls, lo) => {
+                        let kk = lo;
+                        let hi = all;
+                        while (kk < hi) {
+                            const mid = Math.ceil((kk + hi) / 2);
+                            if (size(ls, mid, base) <= STRUCTURED_BUDGET)
+                                kk = mid;
+                            else
+                                hi = mid - 1;
+                        }
+                        return kk;
+                    };
+                    if (size(apart, rest, base) <= STRUCTURED_BUDGET) {
+                        k = most(apart, rest);
+                        lists = apart;
+                        fits = true;
+                        break;
+                    }
+                    // #3269's review: the others are capped anyway, so the named entries stay while the
+                    // others fit at the floor (OutFirst.floor). #3269's second review: each capped level
+                    // holds each entry's own floor (EntryLevel.floor), so the cap starts at its least.
+                    const floor = out.floor;
+                    if (floor) {
+                        const last = floor.at + 1;
+                        // With kk entries kept, the richest capped level from thin[before] to thin[floor.at]
+                        // that fits at the floor or more, at the most inner entries that fit; none where none.
+                        const capped = (kk) => {
+                            for (let j = i; j <= last; j++) {
+                                const lv = levelOf(levels[j]);
+                                if (lv.capped === undefined)
+                                    continue;
+                                const ls = (c) => at(levels[j], c, j - 1, out.level);
+                                let m = lv.least ?? 0;
+                                if (size(ls(m), kk, base) > STRUCTURED_BUDGET)
+                                    continue;
+                                let hi = Math.max(m, ...step.lists.map((p) => longestInside(listOf(data, p.split(".")), lv.capped)));
+                                while (m < hi) {
+                                    const mid = Math.ceil((m + hi) / 2);
+                                    if (size(ls(mid), kk, base) <= STRUCTURED_BUDGET)
+                                        m = mid;
+                                    else
+                                        hi = mid - 1;
+                                }
+                                return ls(m);
+                            }
+                            return undefined;
+                        };
+                        let kk = all;
+                        let got = capped(all);
+                        if (!got) {
+                            // Even the floor does not fit with every named entry: they leave, as many as must
+                            // for it to, and the others then take the most that fits.
+                            const lv = levelOf(levels[last]);
+                            const atLeast = at(levels[last], lv.least ?? 0, last - 1, out.level);
+                            if (size(atLeast, rest, base) <= STRUCTURED_BUDGET) {
+                                kk = most(atLeast, rest);
+                                got = capped(kk);
+                            }
+                        }
+                        if (got) {
+                            lists = got;
+                            k = kk;
+                            if (kk < all)
+                                gone = true;
+                            fits = true;
+                            break;
+                        }
+                    }
+                    gone = true;
+                }
+            }
+            lists = at(thin, undefined, i - 1);
             if (lists.length === 0)
                 break;
             const base = JSON.stringify(apply(lists.map((list) => ({ list, k: 0 })))).length;
-            const top = Math.max(...lists.map((l) => l.n));
-            if (i < levels.length - 1) {
+            const top = Math.max(...lists.map((l) => (gone ? l.n - l.named : l.n)));
+            // #3132: a level that caps a list inside each entry, every entry kept: the most entries of
+            // that inner list, the same number in each, that fit; a level where even none fits is passed.
+            // #3132's review: a level with `least` is taken at that cap or more, or passed.
+            const capped = thin === undefined ? undefined : levelOf(thin).capped;
+            if (capped !== undefined) {
+                const longest = Math.max(0, ...step.lists.map((p) => longestInside(listOf(data, p.split(".")), capped)));
+                const least = (thin === undefined ? undefined : levelOf(thin).least) ?? 0;
+                if (longest > least && size(at(thin, least, i - 1), top, base) <= STRUCTURED_BUDGET) {
+                    let m = least;
+                    let hi = longest - 1;
+                    while (m < hi) {
+                        const mid = Math.ceil((m + hi) / 2);
+                        if (size(at(thin, mid, i - 1), top, base) <= STRUCTURED_BUDGET)
+                            m = mid;
+                        else
+                            hi = mid - 1;
+                    }
+                    lists = at(thin, m, i - 1);
+                    k = top;
+                    fits = true;
+                    break;
+                }
+                if (i < end)
+                    continue;
+                // The last level, and even its least cap does not fit: the entries go on at that cap.
+                lists = at(thin, least, i - 1);
+            }
+            if (i < end) {
                 if (size(lists, top, base) <= STRUCTURED_BUDGET) {
                     k = top;
                     fits = true;
@@ -509,7 +1318,32 @@ export function cutData(data, cut, wholeChars, structured) {
                 }
                 continue;
             }
-            if (size(lists, 0, base) <= STRUCTURED_BUDGET) {
+            if (step.keepAll) {
+                // #3139: every entry stays, at this level; the later steps are cut first.
+                k = top;
+                fits = size(lists, top, base) <= STRUCTURED_BUDGET;
+                break;
+            }
+            // #3132's review: entries leave at the step's leaveAt level, where it names one.
+            if (step.leaveAt && step.thin) {
+                const { level, cap } = step.leaveAt;
+                lists = at(step.thin[level], cap, level);
+            }
+            if (step.whole) {
+                // Every entry or none (#3132's review: data.not_sent_purls).
+                if (size(lists, 0, base) <= STRUCTURED_BUDGET) {
+                    k = size(lists, top, base) <= STRUCTURED_BUDGET ? top : 0;
+                    fits = true;
+                }
+                break;
+            }
+            const chosen = step.leaveAt?.floor && step.leaveLast && lists.length === 1 ? keptByFit(lists[0], base) : undefined;
+            if (chosen) {
+                lists = [chosen.list];
+                k = chosen.k;
+                fits = true;
+            }
+            else if (size(lists, 0, base) <= STRUCTURED_BUDGET) {
                 // The most entries each list of the step keeps with the result inside the budget.
                 let hi = top;
                 while (k < hi) {
@@ -521,21 +1355,89 @@ export function cutData(data, cut, wholeChars, structured) {
                 }
                 fits = true;
             }
+            // #3269's second review: not even one entry fits at its floor (one extreme row, its KEV-listed
+            // matches alone past the budget). The one the leaving order keeps last stays, its capped list
+            // at the most that fit below its floor, at least one; where not even one fits, at the first
+            // later level that fits; and only where none does, no entry.
+            if (fits && k === 0 && top > 0 && step.leaveAt?.floor && step.thin) {
+                const { level } = step.leaveAt;
+                const inner = levelOf(step.thin[level]).capped;
+                let got;
+                if (inner !== undefined) {
+                    const ls = (c) => at(step.thin?.[level], c, level, undefined, true);
+                    if (size(ls(1), 1, base) <= STRUCTURED_BUDGET) {
+                        let c = 1;
+                        let hi = Math.max(1, ...step.lists.map((p) => longestInside(listOf(data, p.split(".")), inner))) - 1;
+                        while (c < hi) {
+                            const mid = Math.ceil((c + hi) / 2);
+                            if (size(ls(mid), 1, base) <= STRUCTURED_BUDGET)
+                                c = mid;
+                            else
+                                hi = mid - 1;
+                        }
+                        got = ls(c);
+                    }
+                }
+                for (let j = level + 1; !got && j < step.thin.length; j++) {
+                    const ls = at(step.thin[j], undefined, j);
+                    if (size(ls, 1, base) <= STRUCTURED_BUDGET)
+                        got = ls;
+                }
+                if (got) {
+                    lists = got;
+                    k = 1;
+                }
+            }
         }
         for (const list of lists)
-            kept.set(list.path, { list, k: Math.min(k, list.n), step: s });
+            kept.set(list.path, { list, k: Math.min(k, list.n), step: s, ...(gone ? { gone: true } : {}) });
         if (fits)
             break;
     }
+    const exact = () => {
+        const { truncated, said } = cutSaid(cut, [...kept.values()], wholeChars, data, false, fit);
+        return JSON.stringify(structured(apply(), truncated, said)).length;
+    };
+    // #3139: every step cut and the result still past the budget: a keepAll step's entries leave now,
+    // the step's first, as many as must, the rest of data as the steps after it left it. The steps
+    // after it then take back what room is left (below), as though it were the step that fits.
+    // #3139's review: with more than one keepAll step, the last one's entries leave first
+    // (cve_remediation's fixed_branches before any vendor advisory).
+    if (!fits) {
+        for (const [s, step] of [...steps.entries()].reverse()) {
+            if (!step.keepAll || fits)
+                continue;
+            const entries = [...kept.values()].filter((e) => e.step === s);
+            if (entries.length === 0)
+                continue;
+            const set = (k) => {
+                for (const e of entries)
+                    e.k = Math.min(k, e.list.n);
+            };
+            set(0);
+            if (exact() > STRUCTURED_BUDGET)
+                continue;
+            let k = 0;
+            let hi = Math.max(...entries.map((e) => e.list.n));
+            while (k < hi) {
+                const mid = Math.ceil((k + hi) / 2);
+                set(mid);
+                if (exact() <= STRUCTURED_BUDGET)
+                    k = mid;
+                else
+                    hi = mid - 1;
+            }
+            set(k);
+            for (const e of entries)
+                e.step = steps.length;
+            fits = true;
+        }
+    }
     // The room the step that fits leaves goes back to the steps emptied before it, the last first,
     // each step's lists keeping at most the same number of their entries, as many as fit, at the
     // level they were thinned to (scan_manifest's not_checked, emptied while its rows were whole,
     // keeps its entries once the thinned rows fit).
     if (fits) {
-        const exact = () => {
-            const { truncated, said } = cutSaid(cut, [...kept.values()], wholeChars, data, false, wholeFit);
-            return JSON.stringify(structured(apply(), truncated, said)).length;
-        };
         const last = Math.max(...[...kept.values()].map((e) => e.step));
         for (let s = last - 1; s >= 0; s--) {
             const entries = [...kept.values()].filter((e) => e.step === s);
@@ -547,6 +1449,13 @@ export function cutData(data, cut, wholeChars, structured) {
             };
             let k = Math.min(...entries.map((e) => e.k));
             let hi = Math.max(...entries.map((e) => e.list.n));
+            if (steps[s].whole) {
+                // Every entry or none (#3132's review).
+                at(hi);
+                if (exact() > STRUCTURED_BUDGET)
+                    at(k);
+                continue;
+            }
             while (k < hi) {
                 const mid = Math.ceil((k + hi) / 2);
                 at(mid);
@@ -558,7 +1467,102 @@ export function cutData(data, cut, wholeChars, structured) {
             at(k);
         }
     }
-    const { truncated, said } = cutSaid(cut, [...kept.values()], wholeChars, data, !fits, wholeFit);
+    // #3132's review: then a giveBack step's entries, in their order in data, take back detail (see
+    // DataCutStep): each the richest level above its own that fits. A RowKeep level is tried whole;
+    // of the capped levels, only the leanest at or above the entry's own (check_sbom's compact one,
+    // or the entry's own), uncapped and then at the most inner entries that fit, so a row takes back
+    // more of its matches compact before fewer of them thinned. #3132's second review: an entry that
+    // takes back nothing is passed, not an end (through round 2 it ended give-back, so a row at the
+    // compact level holding every match, too large to move up, kept every later capped row at its
+    // cap while room was left); the entries that took some are named by position (givenBackSaid).
+    if (fits) {
+        for (const [s, step] of steps.entries()) {
+            if (!step.giveBack || !step.thin)
+                continue;
+            const thin = step.thin;
+            for (const e of [...kept.values()].filter((x) => x.step === s)) {
+                const { list } = e;
+                const own = list.level;
+                // #3269's second review: the one entry kept below its floor takes back nothing (more did not fit).
+                if (own === undefined || list.thin === undefined || list.below)
+                    continue;
+                const whole = listOf(data, list.at);
+                if (!Array.isArray(whole))
+                    continue;
+                let leanestCapped = -1;
+                for (let j = 0; j <= own; j++)
+                    if (levelOf(thin[j]).capped !== undefined)
+                        leanestCapped = j;
+                const tryAt = (i, j, c) => {
+                    const l = levelOf(thin[j]);
+                    list.over.set(i, { entry: thinned(whole[i], thin[j], c), level: j, cap: c, keep: l.keep, ...(l.said && l.capped && c < Number.POSITIVE_INFINITY ? { said: l.said(c) } : {}) });
+                    if (exact() <= STRUCTURED_BUDGET)
+                        return true;
+                    list.over.delete(i);
+                    return false;
+                };
+                for (const i of list.kept(e.k)) {
+                    // #3269: an entry outFirst cut apart takes back nothing (the others come first).
+                    if (list.outThin && list.isNamed(i))
+                        continue;
+                    // An entry its own level already keeps as the richest would is passed, not an end.
+                    if (JSON.stringify(thinned(whole[i], thin[0])) === JSON.stringify(thinned(whole[i], thin[own], list.cap)))
+                        continue;
+                    let took = false;
+                    for (let j = 0; j <= own && !took; j++) {
+                        const l = levelOf(thin[j]);
+                        const inner = innerOf(whole[i], l.capped);
+                        if (l.capped === undefined) {
+                            if (j < own)
+                                took = tryAt(i, j, Number.POSITIVE_INFINITY);
+                            continue;
+                        }
+                        if (j !== leanestCapped)
+                            continue;
+                        // #3269's second review: the cap the entry is cut to, its floor where that is more.
+                        const now = capFor(l, whole[i], list.cap);
+                        if (j < own || now < inner)
+                            took = tryAt(i, j, Number.POSITIVE_INFINITY);
+                        if (took)
+                            break;
+                        let c = j === own ? now + 1 : capFor(l, whole[i], l.least ?? 0);
+                        let hi = inner - 1;
+                        if (c > hi || !tryAt(i, j, c))
+                            continue;
+                        while (c < hi) {
+                            const mid = Math.ceil((c + hi) / 2);
+                            if (tryAt(i, j, mid))
+                                c = mid;
+                            else
+                                hi = mid - 1;
+                        }
+                        took = tryAt(i, j, c);
+                    }
+                }
+            }
+        }
+    }
+    // #3269: last, the entries outFirst sent out come back with the room left, cut to its level, the
+    // last to leave first (they leave first of all, so they come back only where every other entry
+    // stayed), as many as fit.
+    if (fits) {
+        for (const e of kept.values()) {
+            if (!e.gone || e.k < e.list.n - e.list.named)
+                continue;
+            let hi = e.list.n;
+            let k = e.k;
+            while (k < hi) {
+                const mid = Math.ceil((k + hi) / 2);
+                e.k = mid;
+                if (exact() <= STRUCTURED_BUDGET)
+                    k = mid;
+                else
+                    hi = mid - 1;
+            }
+            e.k = k;
+        }
+    }
+    const { truncated, said } = cutSaid(cut, [...kept.values()], wholeChars, data, !fits, fit);
     if (truncated === undefined)
         return undefined;
     const d = apply();