pi-tuck 1.0.1 → 1.0.3

package/dist/src/tuck/core/rank.js

@@ -1,292 +0,0 @@
-import { extractPath } from "./tool-args.js";
-import { compileBrief, planBrief, heredocCloseIndex, isSegmentClosingAssistant } from "./brief.js";
-import { createBriefMeter } from "./brief-meter.js";
-import { TRANSCRIPT_HEADER, transcriptUnits, MAX_RECEIPT_CHARACTERS } from "./transcript.js";
-const DEFAULT_MAX_BLOCKS = 80;
-const DEFAULT_RECENT_BLOCKS = 16;
-const EDIT_TOOL_RE = /^(edit|write|multiedit|quick_edit|target_edit|apply_patch)$/i;
-const READ_TOOL_RE = /^(read|glob|grep|ls|find|semantic_query|semantic_grep|semantic_show)$/i;
-const TEST_COMMAND_RE = /\b(?:bun|npm|pnpm|yarn|node|pytest|cargo|go|mvn|gradle)\b[^\n]*(?:test|spec|check|lint|build|tsc)/i;
-// Durable workflow facts: which PR/issue was acted on, and git state changes.
-// Structural (command shape), not prose — same spirit as TEST_COMMAND_RE.
-const WORKFLOW_COMMAND_RE = /(?:^|\s)(?:gh\s+(?:pr|issue)\s+[a-z-]+|git\s+(?:commit|push|merge|rebase|revert|cherry-pick|tag|reset|checkout|branch)\b)/i;
-const MIN_SEGMENT_CLOSING_ASSISTANT_CHARS = 120;
-// A bash block whose every meaningful line is pure scaffolding (set -e, cd,
-// export, ls, echo, sleep, pwd, comments, heredoc bodies) carries no durable
-// fact. Such blocks get a score penalty so the size-relative budget never
-// pulls them in ahead of real edits/commands when spare chars appear.
-const TRIVIAL_BASH_LINE_RE = /^(?:set\s+[-+]|cd(?:\s+\S+)?$|export\s+\w+=|(?:source|\.)\s+\S+|pwd$|true$|:$|#|ls(?:\s|$)|echo\b|clear$|sleep\b)/;
-const TRIVIAL_BASH_PENALTY = 16;
-const isTrivialOnlyBash = (raw) => {
-    const lines = raw.split("\n");
-    const kept = [];
-    for (let i = 0; i < lines.length; i++) {
-        kept.push(lines[i]);
-        // Skip heredoc bodies (they are content, not scaffolding) using the same
-        // hardened detection as brief.ts: only skip when the terminator exists
-        // downstream, so a stray `<<` never swallows a later real command.
-        const close = heredocCloseIndex(lines, i);
-        if (close !== -1)
-            i = close;
-    }
-    const meaningful = kept.map((l) => l.trim()).filter(Boolean).filter((l) => !TRIVIAL_BASH_LINE_RE.test(l));
-    return meaningful.length === 0;
-};
-const asPathSet = (paths) => new Set((paths ?? []).filter(Boolean));
-const bashCommandFromBlock = (block) => {
-    if (block.kind === "bash")
-        return block.command;
-    if (block.kind === "tool_call" && /^bash$/i.test(block.name) && typeof block.args.command === "string") {
-        return block.args.command;
-    }
-    return undefined;
-};
-const pathFromBlock = (block) => {
-    if (block.kind === "tool_call")
-        return extractPath(block.args) ?? undefined;
-    if (block.kind === "bash") {
-        const match = block.command.match(/(?:^|\s)([\w./-]+\.[\w-]+)(?:\s|$)/);
-        return match?.[1];
-    }
-    return undefined;
-};
-const add = (ranked, points, reason) => {
-    ranked.score += points;
-    ranked.reasons.push(reason);
-};
-const scoreBlock = (block, index, total, modifiedFiles, readFiles) => {
-    const ranked = { block, index, score: 0, reasons: [] };
-    const recency = total <= 1 ? 0 : Math.round((index / (total - 1)) * 12);
-    add(ranked, recency, "recency");
-    if (block.kind === "user")
-        add(ranked, 18, "user-turn");
-    if (block.kind === "assistant")
-        add(ranked, 10, "assistant-context");
-    if (block.kind === "notice")
-        add(ranked, 10, "framework-notice");
-    if (block.kind === "tool_result")
-        add(ranked, 1, "tool-result-low-value");
-    if (block.kind === "tool_call") {
-        const command = bashCommandFromBlock(block);
-        if (EDIT_TOOL_RE.test(block.name))
-            add(ranked, 34, "edit-tool");
-        else if (command && TEST_COMMAND_RE.test(command))
-            add(ranked, 26, "test-command");
-        else if (READ_TOOL_RE.test(block.name))
-            add(ranked, 6, "read-tool");
-        else
-            add(ranked, 12, "tool-call");
-        if (command && WORKFLOW_COMMAND_RE.test(command))
-            add(ranked, 14, "workflow-command");
-        if (command && isTrivialOnlyBash(command))
-            add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
-    }
-    if (block.kind === "bash") {
-        add(ranked, 8, "bash");
-        if (block.exitCode != null && block.exitCode !== 0)
-            add(ranked, 24, "nonzero-exit");
-        if (TEST_COMMAND_RE.test(block.command))
-            add(ranked, 22, "test-command");
-        if (WORKFLOW_COMMAND_RE.test(block.command))
-            add(ranked, 14, "workflow-command");
-        // Penalize scaffolding-only commands, but not ones that failed (a failed
-        // `ls`/`cd` still records a real state fact via nonzero-exit).
-        if (isTrivialOnlyBash(block.command) && !(block.exitCode != null && block.exitCode !== 0)) {
-            add(ranked, -TRIVIAL_BASH_PENALTY, "trivial-bash");
-        }
-    }
-    const path = pathFromBlock(block);
-    if (path) {
-        if (modifiedFiles.has(path))
-            add(ranked, 18, "hook-modified-file");
-        if (readFiles.has(path))
-            add(ranked, 6, "hook-read-file");
-    }
-    if (block.kind === "tool_result" && block.text.length > 1000)
-        add(ranked, -8, "long-tool-result");
-    return ranked;
-};
-const boostAdjacency = (ranked) => {
-    const important = ranked
-        .filter((r) => r.score >= 34 || r.reasons.includes("edit-tool") || r.reasons.includes("test-command") || r.reasons.includes("nonzero-exit"))
-        .map((r) => r.index);
-    for (const idx of important) {
-        for (let i = idx - 1; i >= Math.max(0, idx - 8); i--) {
-            if (ranked[i].block.kind === "user") {
-                add(ranked[i], 10, "near-important-event");
-                break;
-            }
-        }
-        for (let i = idx - 1; i >= Math.max(0, idx - 4); i--) {
-            if (ranked[i].block.kind === "assistant") {
-                add(ranked[i], 7, "near-important-event");
-                break;
-            }
-        }
-        for (let i = idx + 1; i <= Math.min(ranked.length - 1, idx + 4); i++) {
-            if (ranked[i].block.kind === "assistant" || ranked[i].block.kind === "bash") {
-                add(ranked[i], 5, "after-important-event");
-                break;
-            }
-        }
-    }
-};
-const boostSegmentClosingAssistants = (ranked, blocks) => {
-    for (const current of ranked) {
-        if (current.block.kind !== "assistant")
-            continue;
-        if (current.block.text.trim().length < MIN_SEGMENT_CLOSING_ASSISTANT_CHARS)
-            continue;
-        if (isSegmentClosingAssistant(blocks, current.index))
-            add(current, 14, "segment-closing-assistant");
-    }
-};
-export const rankBriefBlocks = (blocks, options = {}) => {
-    const modifiedFiles = asPathSet(options.fileOps?.modifiedFiles);
-    const readFiles = asPathSet(options.fileOps?.readFiles);
-    const ranked = blocks.map((block, index) => scoreBlock(block, index, blocks.length, modifiedFiles, readFiles));
-    boostAdjacency(ranked);
-    boostSegmentClosingAssistants(ranked, blocks);
-    return ranked;
-};
-export const selectRankedBriefBlocks = (blocks, options = {}) => {
-    // A rendered allowance owns capacity. An independent count must not discard
-    // fitting original dialogue; all blocks were already normalized in memory.
-    const maxBlocks = options.maxBlocks ?? (options.maxBriefChars != null ? blocks.length : DEFAULT_MAX_BLOCKS);
-    // Size-relative budget: when a ceiling + slope are provided, the effective
-    // char budget scales with transcript length (block count) between the floor
-    // (maxBriefChars) and the ceiling. Larger transcripts carry more high-value
-    // long-tail, so they earn more brief budget; small sessions stay at the floor.
-    const maxBriefChars = options.maxBriefChars != null && options.maxBriefCharsCeiling != null && options.briefCharsPerBlock != null
-        ? Math.round(Math.min(options.maxBriefCharsCeiling, Math.max(options.maxBriefChars, options.briefCharsPerBlock * blocks.length)))
-        : options.maxBriefChars;
-    // Fast path: nothing to trim by count and no char budget to enforce.
-    if (blocks.length <= maxBlocks && maxBriefChars == null && options.maxBriefUnits == null)
-        return blocks;
-    const preserveRecentBlocks = Math.min(options.preserveRecentBlocks ?? DEFAULT_RECENT_BLOCKS, maxBlocks);
-    const ranked = rankBriefBlocks(blocks, options);
-    const selected = new Set();
-    // Charge the actual candidate serialization. Adjacent-block truncation and
-    // tool omission notices can change its size; isolated-block estimates cannot certify it.
-    // The meter keeps that size current as blocks join; the final render below remains the authority.
-    const excerpts = new WeakMap();
-    const full = new Set();
-    const meter = createBriefMeter(blocks, options.mandatorySourceIndices, excerpts);
-    const within = (size) => (maxBriefChars == null || size.chars <= maxBriefChars) &&
-        (options.maxBriefUnits == null || size.units <= options.maxBriefUnits);
-    const admit = (indices, preferFull = false) => {
-        const added = indices.filter(i => !selected.has(i));
-        if (!added.length && !preferFull)
-            return true;
-        if (selected.size + added.length > maxBlocks)
-            return false;
-        const promoted = preferFull ? indices.filter(i => ["user", "assistant", "bash"].includes(blocks[i].kind) && !full.has(blocks[i])) : [];
-        // Notices are best effort: never overflow or displace otherwise fitting text.
-        const fits = () => { const { withNotices, withoutNotices } = meter.size(added); return within(withNotices) || within(withoutNotices); };
-        for (const i of added)
-            meter.select(i);
-        for (const i of promoted)
-            meter.promote(i);
-        if (!fits()) {
-            for (const i of promoted.splice(0))
-                meter.demote(i);
-            // A whole shell proposal that does not fit is withdrawn, not retried as an excerpt.
-            if ((preferFull && indices.some(i => blocks[i].kind === "bash")) || !fits()) {
-                for (const i of added)
-                    meter.unselect(i);
-                return false;
-            }
-        }
-        for (const i of added)
-            selected.add(i);
-        meter.commit(added);
-        for (const i of promoted)
-            full.add(blocks[i]);
-        return true;
-    };
-    // Keep the latest blocks to preserve local continuity, iterating NEWEST first
-    // so the most recent context is guaranteed. When a char budget is active these
-    // are charged against it too and over-budget blocks are skipped -- otherwise a
-    // run of large recent blocks could blow past maxBriefChars (the old bug on very
-    // long transcripts, where preserve-recent alone exceeded the budget).
-    for (let i = blocks.length - 1; i >= Math.max(0, blocks.length - preserveRecentBlocks); i--) {
-        // Historical action overviews compete after the conversational base. Fresh
-        // native rounds are protected by the adapter, outside this old-prefix view.
-        if (["tool_result", "tool_call", "bash"].includes(blocks[i].kind))
-            continue;
-        if (selected.has(i))
-            continue;
-        if (!admit([i]))
-            continue;
-    }
-    // Structural exchanges are derived from the original chronology. A user
-    // carries prose from the preceding assistant message, including prose before
-    // that message's trailing calls. Only explicit source identity crosses calls.
-    const groups = ranked.filter(r => r.block.kind === "user").map(item => {
-        let preceding = item.index - 1;
-        while (preceding >= 0 && blocks[preceding].kind === "tool_result")
-            preceding--;
-        const previous = blocks[preceding];
-        const prose = [];
-        if (previous?.kind === "assistant" || previous?.kind === "tool_call") {
-            const source = previous.sourceIndex;
-            for (let i = preceding; i >= 0; i--) {
-                if (source === undefined ? i !== preceding : blocks[i].sourceIndex !== source)
-                    break;
-                if (blocks[i].kind === "assistant")
-                    prose.unshift(i);
-            }
-        }
-        return [...prose, item.index];
-    }).reverse();
-    // Admit the conversational base before spending room on any full proposal.
-    // Otherwise a newly fitting recent assistant can crowd out an older user.
-    for (const group of groups) {
-        if (!admit(group)) {
-            // Bounded atomicity: an oversized pair must not exclude a useful user turn.
-            admit([group.at(-1)]);
-        }
-    }
-    const ordered = [...ranked].sort((a, b) => b.score - a.score || b.index - a.index);
-    for (const item of ordered) {
-        if (selected.size >= maxBlocks)
-            break;
-        if (selected.has(item.index))
-            continue;
-        if (item.block.kind === "tool_result")
-            continue;
-        if (!admit([item.index]))
-            continue;
-    }
-    // Complete the existing coverage pass before expanding already represented
-    // user wording. Whole proposals/choices are still eligible in spare room.
-    for (const i of [...selected].sort((a, b) => b - a))
-        if (blocks[i].kind === "user")
-            admit([i], true);
-    // Expand selected assistant prose only into spare capacity. A large recent
-    // message must not consume the budget before user exchanges are considered.
-    for (const i of [...selected].sort((a, b) => b - a))
-        if (blocks[i].kind === "assistant")
-            admit([i], true);
-    // Cheap exact observations use only spare allowance after dialogue. Size
-    // and recency are signals, not proof of usefulness, freshness or success.
-    for (let i = blocks.length - 1; i >= 0; i--) {
-        const block = blocks[i];
-        if (block.kind === "tool_result" && block.originalReceipt)
-            admit([i]);
-    }
-    // Enrich already retained shell events only after the unchanged base. Whole
-    // stored output may be truncated; it is historical evidence, not verification.
-    for (const i of [...selected].sort((a, b) => b - a)) {
-        const block = blocks[i];
-        if (block.kind === "bash" && block.sourceIndex !== undefined && block.output.length <= MAX_RECEIPT_CHARACTERS)
-            admit([i], true);
-    }
-    const result = [...selected].sort((a, b) => a - b).map((i) => blocks[i]);
-    planBrief(result, full, blocks, options.mandatorySourceIndices);
-    const rendered = TRANSCRIPT_HEADER + "\n" + compileBrief(result, excerpts);
-    if ((maxBriefChars != null && rendered.length > maxBriefChars) ||
-        (options.maxBriefUnits != null && transcriptUnits(rendered) > options.maxBriefUnits))
-        planBrief(result, full, blocks, options.mandatorySourceIndices, false);
-    return result;
-};

package/src/tuck/core/brief-meter.ts

@@ -1,235 +0,0 @@
-import type { NormalizedBlock } from "../types";
-import { absorbCall, blockRecords, coveredCallKey, decorateRecord, isOmittable, noticeTimes, omissionRecord, receiptKey, repeatsCall, segmentClosing,
-  type ExcerptCache } from "./brief";
-import { TRANSCRIPT_HEADER, lineUnits, type TranscriptRecord } from "./transcript";
-
-/** A set of integers in [0, size) with ordered neighbour queries, in a tree of 32-bit words. */
-export class IndexSet {
-  private readonly levels: Uint32Array[] = [];
-  constructor(size: number) {
-    let words = Math.max(1, size);
-    do { words = Math.ceil(words / 32); this.levels.push(new Uint32Array(words)); } while (words > 1);
-  }
-  has(i: number): boolean { return (this.levels[0]![i >>> 5]! & (1 << (i & 31))) !== 0; }
-  add(i: number): void {
-    for (const level of this.levels) {
-      const word = i >>> 5, was = level[word]!;
-      level[word] = was | (1 << (i & 31));
-      if (was !== 0) return;
-      i = word;
-    }
-  }
-  remove(i: number): void {
-    for (const level of this.levels) {
-      const word = i >>> 5;
-      level[word] = level[word]! & ~(1 << (i & 31));
-      if (level[word] !== 0) return;
-      i = word;
-    }
-  }
-  /** The smallest member above `i`, or -1. */
-  next(i: number): number {
-    for (let l = 0; l < this.levels.length; l++) {
-      const word = i >>> 5, bit = i & 31;
-      const rest = bit === 31 ? 0 : this.levels[l]![word]! & (-1 << (bit + 1));
-      if (rest === 0) { i = word; continue; }
-      let at = (word << 5) | (31 - Math.clz32(rest & -rest));
-      for (let k = l - 1; k >= 0; k--) { const w = this.levels[k]![at]!; at = (at << 5) | (31 - Math.clz32(w & -w)); }
-      return at;
-    }
-    return -1;
-  }
-  /** The largest member below `i`, or -1. */
-  prev(i: number): number {
-    for (let l = 0; l < this.levels.length; l++) {
-      const word = i >>> 5, bit = i & 31;
-      const rest = this.levels[l]![word]! & ~(-1 << bit);
-      if (rest === 0) { i = word; continue; }
-      let at = (word << 5) | (31 - Math.clz32(rest));
-      for (let k = l - 1; k >= 0; k--) at = (at << 5) | (31 - Math.clz32(this.levels[k]![at]!));
-      return at;
-    }
-    return -1;
-  }
-}
-
-export interface BriefSize { chars: number; units: number }
-
-export interface BriefMeter {
-  /** Block `i` joins the selection, or leaves it again. */
-  select(i: number): void;
-  unselect(i: number): void;
-  /** Block `i` is rendered whole instead of as an excerpt, or no longer. */
-  promote(i: number): void;
-  demote(i: number): void;
-  /** The rendered size of the selection, were the unselected blocks `added` selected too, with and without the omission notices. */
-  size(added: readonly number[]): { withNotices: BriefSize; withoutNotices: BriefSize };
-  /** Settles the omission notices for blocks selected for good. */
-  commit(added: readonly number[]): void;
-}
-
-/**
- * The size of `TRANSCRIPT_HEADER + "\n" + compileBrief(selected)` as blocks join, kept up to date by recomputing only the records a change
- * can affect, which are those of the block, its neighbours and the identical calls merged with them. This is the admission loop's yardstick,
- * so it must equal what the full render measures; the final render in `selectRankedBriefBlocks` remains the authority.
- *
- * It relies on what `normalize` guarantees for the blocks of one brief: they are distinct objects; all carry the same `sourceTimes` or none
- * does; and notices that share a `sourceEntryId` share a `sourceTime`.
- */
-export const createBriefMeter = (blocks: NormalizedBlock[], mandatory: ReadonlySet<number> | undefined, cache: ExcerptCache): BriefMeter => {
-  const n = blocks.length;
-  const closing = segmentClosing(blocks);
-  const times = blocks[0]?.sourceTimes;
-  const entryTimes = noticeTimes(blocks);
-  const lengths = new WeakMap<TranscriptRecord, number>();
-  const lengthOf = (record: TranscriptRecord): number => {
-    let length = lengths.get(record);
-    if (length === undefined) lengths.set(record, length = JSON.stringify(decorateRecord(record, times, entryTimes)).length);
-    return length;
-  };
-
-  // The state of each block: selected, rendered whole, and the records it renders alone while it has any (`active`).
-  const selected = new Uint8Array(n), whole = new Uint8Array(n);
-  const records: (TranscriptRecord[] | undefined)[] = new Array(n);
-  const rendered: (TranscriptRecord[] | undefined)[][] = [new Array(n), new Array(n)];
-  const active = new IndexSet(n);
-  // Blocks whose first record is a repeat of the record before it fold into it; the rest of the output follows from these relations.
-  const merged = new Uint8Array(n);
-  const contributedChars = new Int32Array(n), contributedUnits = new Int32Array(n), contributedRecords = new Int32Array(n);
-  let chars = 0, units = 0, count = 0;
-
-  // A selected receipt makes the overview of the call it quotes redundant.
-  const callKeys: (string | undefined)[] = new Array(n);
-  const receiptKeys: (string | undefined)[] = new Array(n);
-  const callsOf = new Map<string, number[]>(), receipts = new Map<string, number>();
-  blocks.forEach((block, i) => {
-    const call = coveredCallKey(block);
-    if (call !== undefined) { callKeys[i] = call; const calls = callsOf.get(call); if (calls) calls.push(i); else callsOf.set(call, [i]); }
-    receiptKeys[i] = receiptKey(block);
-  });
-
-  const own = (i: number): TranscriptRecord[] | undefined => {
-    const block = blocks[i]!, key = callKeys[i];
-    if (key !== undefined && receipts.get(key)) return undefined;
-    const slot = rendered[whole[i]!]!;
-    const result = slot[i] ??= blockRecords(block, { full: whole[i] === 1, closing: closing.has(block), mandatory, bounded: true, covered: false }, cache);
-    return result.length ? result : undefined;
-  };
-
-  const repeats = (a: number, b: number): boolean => {
-    const next = records[b]!;
-    return next.length === 1 && repeatsCall(records[a]!.at(-1), next[0]!);
-  };
-
-  const first = (from: number): number => active.has(from) ? from : active.next(from);
-
-  const setRecords = (j: number, next: TranscriptRecord[] | undefined): void => {
-    if (records[j] === next) return;
-    // Every group of repeats that the change can reach: from the head of the group before `j` to the end of the group after it.
-    const before = active.prev(j), after = active.next(j);
-    let low = j, high = j;
-    if (before !== -1) for (low = before; merged[low]; low = active.prev(low));
-    if (after !== -1) for (high = after; ;) { const further = active.next(high); if (further === -1 || !merged[further]) break; high = further; }
-    for (let b = first(low); b !== -1 && b <= high; b = active.next(b)) {
-      chars -= contributedChars[b]!; units -= contributedUnits[b]!; count -= contributedRecords[b]!;
-      contributedChars[b] = contributedUnits[b] = contributedRecords[b] = 0;
-    }
-    records[j] = next;
-    if (next) active.add(j); else active.remove(j);
-    let group: number[] = [];
-    const settle = () => {
-      if (!group.length) return;
-      const head = records[group[0]!]!;
-      const shown = group.length === 1 ? head :
-        [group.slice(1).reduce((all, b) => absorbCall(all, records[b]![0]!), head[0]!)];
-      for (const record of shown) {
-        const length = lengthOf(record);
-        contributedChars[group[0]!] += length; contributedUnits[group[0]!] += lineUnits(length); contributedRecords[group[0]!]++;
-      }
-      chars += contributedChars[group[0]!]!; units += contributedUnits[group[0]!]!; count += contributedRecords[group[0]!]!;
-    };
-    for (let b = first(low); b !== -1 && b <= high; b = active.next(b)) {
-      const previous = active.prev(b);
-      merged[b] = previous !== -1 && repeats(previous, b) ? 1 : 0;
-      if (!merged[b]) { settle(); group = []; }
-      group.push(b);
-    }
-    settle();
-  };
-  const refresh = (i: number) => setRecords(i, selected[i] ? own(i) : undefined);
-
-  const quoted = (i: number, delta: 1 | -1) => {
-    const key = receiptKeys[i];
-    if (key === undefined) return;
-    const now = (receipts.get(key) ?? 0) + delta;
-    receipts.set(key, now);
-    if (now === (delta === 1 ? 1 : 0)) for (const call of callsOf.get(key) ?? []) if (selected[call]) refresh(call);
-  };
-
-  // The omission notices say how many unselected user and assistant text blocks there are and where the first of them were read.
-  const roles = (["user", "assistant"] as const).map(role => {
-    const perSource = new Map<number, number>();
-    let total = 0, unlocated = 0;
-    for (const block of blocks) if (block.kind === role && isOmittable(block, mandatory)) {
-      total++;
-      if (block.sourceIndex === undefined) unlocated++; else perSource.set(block.sourceIndex, (perSource.get(block.sourceIndex) ?? 0) + 1);
-    }
-    const sources = [...perSource.keys()].sort((a, b) => a - b);
-    const ids = new Map(sources.map((source, id) => [source, id]));
-    const alive = new IndexSet(sources.length);
-    sources.forEach((_, id) => alive.add(id));
-    return { role, total, unlocated, perSource, sources, ids, alive };
-  });
-  const omittedBy = (added: readonly number[], role: typeof roles[number]) => {
-    let removed = 0, unlocated = 0;
-    const taken = new Map<number, number>();
-    for (const i of added) {
-      const block = blocks[i]!;
-      if (block.kind !== role.role || !isOmittable(block, mandatory)) continue;
-      removed++;
-      if (block.sourceIndex === undefined) unlocated++; else taken.set(block.sourceIndex, (taken.get(block.sourceIndex) ?? 0) + 1);
-    }
-    return { removed, unlocated, taken };
-  };
-  const notice = (added: readonly number[], role: typeof roles[number]): TranscriptRecord | undefined => {
-    const { removed, unlocated, taken } = omittedBy(added, role);
-    if (role.total === removed) return undefined;
-    const gone = new Set<number>();
-    for (const [source, k] of taken) if (role.perSource.get(source) === k) gone.add(source);
-    const sources: number[] = [];
-    for (let id = role.alive.has(0) ? 0 : role.alive.next(0); id !== -1 && sources.length < 9; id = role.alive.next(id))
-      if (!gone.has(role.sources[id]!)) sources.push(role.sources[id]!);
-    return omissionRecord(role.role, role.total - removed, sources, role.unlocated > unlocated);
-  };
-
-  const header = TRANSCRIPT_HEADER.length + 1;
-  const rendering = (c: number, u: number, k: number): BriefSize => k === 0 ? { chars: header, units: 2 } : { chars: header + c + k - 1, units: 1 + u };
-
-  return {
-    select(i) { selected[i] = 1; quoted(i, 1); refresh(i); },
-    unselect(i) { selected[i] = 0; refresh(i); quoted(i, -1); },
-    promote(i) { whole[i] = 1; refresh(i); },
-    demote(i) { whole[i] = 0; refresh(i); },
-    size(added) {
-      let c = 0, u = 0, k = 0;
-      for (const role of roles) {
-        const record = notice(added, role);
-        if (!record) continue;
-        const length = lengthOf(record);
-        c += length; u += lineUnits(length); k++;
-      }
-      return { withNotices: rendering(chars + c, units + u, count + k), withoutNotices: rendering(chars, units, count) };
-    },
-    commit(added) {
-      for (const role of roles) {
-        const { removed, unlocated, taken } = omittedBy(added, role);
-        role.total -= removed; role.unlocated -= unlocated;
-        for (const [source, k] of taken) {
-          const left = role.perSource.get(source)! - k;
-          role.perSource.set(source, left);
-          if (left === 0) role.alive.remove(role.ids.get(source)!);
-        }
-      }
-    },
-  };
-};