@plurnk/plurnk-service 1.26.0 → 1.28.0

package/dist/core/packet-wire.js

@@ -2,13 +2,15 @@ import { TurnDisposition } from "@plurnk/plurnk-contracts";
 import { relative, sep } from "node:path";
 import { Problems, Validator } from "@plurnk/plurnk-contracts";
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
+import BodyPreview from "../content/body-preview.js";
 import { renderTarget } from "./plurnk-uri.js";
 import GitState from "./git-state.js";
 import LogBody from "./LogBody.js";
 import LogEntryProjection from "./LogEntryProjection.js";
 import LogVisibility from "./LogVisibility.js";
-import BodyPreview from "../content/body-preview.js";
 import ScopeFormat from "../content/scope-format.js";
+import PatternEdits from "../content/pattern-edits.js";
+import { Results as SchemeResults } from "@plurnk/plurnk-schemes";
 import { assertEditReceipt, assertResourceEffects, LineAnchors, } from "../content/index.js";
 // {§packet-attachment-parts} — the attachment kinds and their readout weights live in one table.
 import { audioWeight, imageWeight, pdfWeight } from "./attachments.js";
@@ -45,8 +47,7 @@ export default class PacketWire {
         return pointers.length === 0 ? "" : `[${pointers.join(",\n")}]`;
     }
     // Non-terminal model-facing observations are deliberately separate from
-    // operation failures. Producer messages are normalized and bounded by the
-    // shared preview limit; typed positions remain legible.
+    // operation failures. Producer messages are normalized; typed positions remain legible.
     static renderNotices(notices) {
         const observations = Array.isArray(notices) ? notices : [];
         return observations.map((notice) => {
@@ -54,9 +55,7 @@ export default class PacketWire {
             const rawMessage = typeof notice.message === "string"
                 ? notice.message.replace(/\s+/g, " ").trim()
                 : "";
-            const message = rawMessage.length > 0
-                ? PacketWire.#preview(rawMessage).text
-                : "";
+            const message = rawMessage;
             const position = notice.position?.type === "content-offset"
                 ? ` @ ${String(notice.position.line)}:${String(notice.position.column)}`
                 : "";
@@ -91,12 +90,12 @@ export default class PacketWire {
     static renderLog(entries, weighContent, options = {}) {
         return PacketWire.renderLogWithAccounting(entries, weighContent, options).content;
     }
-    // {§tokenomics-pressure-inventory} — the wire row and its reclaimable-body
-    // accounting come from one render pass; packet assembly never re-parses its text.
+    // {§context-gauge} — the wire row and its reclaimable-body accounting come from one render
+    // pass; packet assembly never re-parses its text.
     static renderLogWithAccounting(entries, weighContent, options = {}) {
         const log = Array.isArray(entries) ? entries : [];
         if (log.length === 0)
-            return { content: "", records: [], curationTargets: [], attachments: [], emissions: [], unadmittedOutput: [], newOverflow: false };
+            return { content: "", records: [], curationTargets: [], attachments: [], emissions: [], bodied: [] };
         const rows = PacketWire.#renderLogEntries(log, weighContent, options);
         const records = rows.map(({ content }) => content);
         return {
@@ -105,8 +104,7 @@ export default class PacketWire {
             curationTargets: rows.flatMap(({ curationTarget }) => curationTarget === null ? [] : [curationTarget]),
             attachments: rows.flatMap(({ attachment }) => attachment === null ? [] : [attachment]),
             emissions: rows.flatMap(({ emission }) => emission === null ? [] : [emission]),
-            unadmittedOutput: rows.flatMap(({ unadmittedOutput }) => unadmittedOutput === null ? [] : [unadmittedOutput]),
-            newOverflow: rows.some(({ newOverflow }) => newOverflow),
+            bodied: rows.flatMap(({ bodied }) => bodied === null ? [] : [bodied]),
         };
     }
     // Read one section's content by name off a packet (Engine's or re-parsed).
@@ -330,10 +328,52 @@ export default class PacketWire {
             throw new TypeError("A packet log row requires an addressable coordinate.");
         return `log:///${coordinate}/${leaf}`;
     }
-    // One preview function for every bounded model-facing projection. Lines
-    // protect ordinary documents and Unicode characters protect a single-line
-    // bomb. Once a physical line is complete, a character cut retreats to that
-    // line boundary rather than exposing a partial coordinate prefix.
+    static #visibleBody(entry, body) {
+        const trimmed = LogVisibility.parse(entry.folded ?? LogVisibility.OPEN);
+        const folded = LogVisibility.combine(LogVisibility.parse(entry.initial_folded ?? LogVisibility.OPEN), trimmed);
+        const lines = TextCoordinates.logicalLines(body.content);
+        const totalLines = lines.length;
+        const clipped = LogVisibility.clipped(folded, totalLines);
+        const ordinals = LogVisibility.visibleLineOrdinals(clipped, totalLines);
+        const readableOrdinals = LogVisibility.visibleLineOrdinals(trimmed, totalLines);
+        const select = (selected) => selected.map((ordinal) => {
+            const line = lines[ordinal - 1];
+            return body.content.slice(line.start, line.end);
+        }).join("");
+        return {
+            content: select(ordinals),
+            ordinals,
+            readableContent: select(readableOrdinals),
+            readableOrdinals,
+            folded: clipped,
+            trimmed: LogVisibility.clipped(trimmed, totalLines),
+            totalLines,
+            fullyFolded: LogVisibility.fullyFolded(clipped, totalLines),
+        };
+    }
+    // {§message-arrival} — an inbound SEND row: harness-published, the sender's statement as its
+    // sent side. {§message-causal-source}: a `source` names the actor; absence is the owner.
+    static isArrival(e) {
+        if (e.op !== "SEND" || e.origin !== "_plurnk")
+            return false;
+        const attrs = typeof e.attrs === "string" ? JSON.parse(e.attrs) : e.attrs;
+        return attrs !== null && typeof attrs === "object" && attrs.kind === "message";
+    }
+    // {§markerless-first-page} — a body the model did not author or ask for exactly takes its first page in
+    // the packet: not the model's own row, not a retrieval (paged at its source), not an emission row,
+    // and not the operator's message, which keeps its own rule ({§message-projection}).
+    static #receivedBody(e, op) {
+        if (e.origin === "model" || op === "READ" || op === "FIND" || LogEntryProjection.isEmission(e))
+            return false;
+        if (PacketWire.isArrival(e)) {
+            const source = typeof e.source === "string" ? e.source : null;
+            return source !== null && source.startsWith("worker://");
+        }
+        return true;
+    }
+    // One preview function for every bounded model-facing projection. Lines protect ordinary
+    // documents and Unicode characters protect a single-line bomb. Once a physical line is complete,
+    // a character cut retreats to that line boundary rather than exposing a partial coordinate prefix.
     static #preview(text) {
         const coordinates = new TextCoordinates(text);
         const physicalLines = coordinates.logicalLines();
@@ -376,19 +416,16 @@ export default class PacketWire {
             const runs = [];
             for (const ordinal of selectedOrdinals) {
                 const previous = runs.at(-1);
-                if (previous === undefined || ordinal !== previous[1] + 1) {
+                if (previous === undefined || ordinal !== previous[1] + 1)
                     runs.push([ordinal, ordinal]);
-                }
-                else {
+                else
                     previous[1] = ordinal;
-                }
             }
             const selected = runs.map(([start, finish]) => ScopeFormat.lines(start, finish)).join(",");
             return `${selected} of ${ScopeFormat.count("line", TextCoordinates.logicalLines(completeContent).length)}`;
         }
         const local = coordinates.regionFromOffsets(0, end);
-        const complete = new TextCoordinates(completeContent)
-            .regionFromOffsets(0, completeContent.length);
+        const complete = new TextCoordinates(completeContent).regionFromOffsets(0, completeContent.length);
         if (local === null || complete === null) {
             throw new Error("a sparse character-bound chunk must resolve to exact text coordinates");
         }
@@ -397,140 +434,7 @@ export default class PacketWire {
         if (startLine === undefined || endLine === undefined) {
             throw new Error("a sparse character-bound chunk must map to canonical body lines");
         }
-        return `${ScopeFormat.region({
-            ...local,
-            startLine,
-            endLine,
-        })} of ${ScopeFormat.region(complete)}`;
-    }
-    static #promptProjection(body, budget, weighContent, render = (content) => PacketWire.#renderContentBody(content, body.startLine, null)) {
-        const weightAt = (end) => weighContent(render(body.content.slice(0, end)));
-        if (weightAt(body.content.length) <= budget) {
-            return { text: body.content, cut: false, chunk: null };
-        }
-        if (budget <= 0)
-            return { text: "", cut: true, chunk: null };
-        const coordinates = new TextCoordinates(body.content);
-        const lines = coordinates.logicalLines();
-        const completeLineEnds = lines
-            .filter((line) => line.separator.length > 0 && line.end < body.content.length)
-            .map((line) => line.end);
-        let low = 0;
-        let high = completeLineEnds.length;
-        while (low < high) {
-            const middle = Math.floor((low + high) / 2);
-            if (weightAt(completeLineEnds[middle]) <= budget)
-                low = middle + 1;
-            else
-                high = middle;
-        }
-        const completeLineEnd = low === 0 ? 0 : completeLineEnds[low - 1];
-        if (completeLineEnd > 0) {
-            return {
-                text: body.content.slice(0, completeLineEnd),
-                cut: true,
-                chunk: PacketWire.#chunk(coordinates, lines, completeLineEnd, body.content.length),
-            };
-        }
-        const firstLineEnd = lines[0]?.contentEnd ?? body.content.length;
-        const offsets = [0];
-        let offset = 0;
-        for (const codePoint of body.content.slice(0, firstLineEnd)) {
-            offset += codePoint.length;
-            offsets.push(offset);
-        }
-        low = 0;
-        high = offsets.length;
-        while (low < high) {
-            const middle = Math.floor((low + high) / 2);
-            if (weightAt(offsets[middle]) <= budget)
-                low = middle + 1;
-            else
-                high = middle;
-        }
-        const characterEnd = low === 0 ? 0 : offsets[low - 1];
-        if (characterEnd === 0)
-            return { text: "", cut: true, chunk: null };
-        return {
-            text: body.content.slice(0, characterEnd),
-            cut: true,
-            chunk: PacketWire.#chunk(coordinates, lines, characterEnd, body.content.length),
-        };
-    }
-    static #visibleBody(entry, body) {
-        const trimmed = LogVisibility.parse(entry.folded ?? LogVisibility.OPEN);
-        const folded = LogVisibility.combine(LogVisibility.parse(entry.initial_folded ?? LogVisibility.OPEN), trimmed);
-        const lines = TextCoordinates.logicalLines(body.content);
-        const totalLines = lines.length;
-        const clipped = LogVisibility.clipped(folded, totalLines);
-        const ordinals = LogVisibility.visibleLineOrdinals(clipped, totalLines);
-        const readableOrdinals = LogVisibility.visibleLineOrdinals(trimmed, totalLines);
-        const select = (selected) => selected.map((ordinal) => {
-            const line = lines[ordinal - 1];
-            return body.content.slice(line.start, line.end);
-        }).join("");
-        return {
-            content: select(ordinals),
-            ordinals,
-            readableContent: select(readableOrdinals),
-            readableOrdinals,
-            folded: clipped,
-            trimmed: LogVisibility.clipped(trimmed, totalLines),
-            totalLines,
-            fullyFolded: LogVisibility.fullyFolded(clipped, totalLines),
-        };
-    }
-    // {§message-arrival} — an inbound SEND row: harness-published, the sender's statement as its
-    // sent side. {§message-causal-source}: a `source` names the actor; absence is the owner.
-    static isArrival(e) {
-        if (e.op !== "SEND" || e.origin !== "_plurnk")
-            return false;
-        const attrs = typeof e.attrs === "string" ? JSON.parse(e.attrs) : e.attrs;
-        return attrs !== null && typeof attrs === "object" && attrs.kind === "message";
-    }
-    // {§message-projection} — a peer worker's message takes the ordinary bounds; every other
-    // arrival, the loop's own assignment included, shares the allowance.
-    static isExteriorArrival(e) {
-        return PacketWire.isArrival(e) && !(typeof e.source === "string" && e.source.startsWith("worker://"));
-    }
-    static #promptProjectionWeights(entries, bodies, visibility, weighContent, budget) {
-        if (budget === undefined)
-            return new Map();
-        if (!Number.isSafeInteger(budget) || budget < 0) {
-            throw new RangeError(`promptProjectionWeight must be a non-negative safe integer, got ${JSON.stringify(budget)}`);
-        }
-        const costs = entries.flatMap((entry, index) => {
-            // {§message-projection} — an arrival from outside the workspace shares the allowance;
-            // a peer worker's message takes the ordinary bounds.
-            if (!PacketWire.isExteriorArrival(entry) || bodies[index].content.length === 0)
-                return [];
-            const body = bodies[index];
-            const visible = visibility[index];
-            const width = body.startLine === null || visible.totalLines === 0
-                ? 0
-                : String(body.startLine + visible.totalLines - 1).length;
-            const rendered = PacketWire.#renderContentBody(body.content, body.startLine, null, null, width, body.startLine === null ? null : visible.ordinals);
-            return [{ index, cost: weighContent(rendered) }];
-        });
-        const allocations = new Map();
-        let remaining = budget;
-        let active = costs;
-        while (active.length > 0) {
-            const share = Math.floor(remaining / active.length);
-            const complete = active.filter(({ cost }) => cost <= share);
-            if (complete.length === 0) {
-                const extra = remaining % active.length;
-                active.forEach(({ index }, position) => allocations.set(index, share + (position < extra ? 1 : 0)));
-                break;
-            }
-            for (const { index, cost } of complete) {
-                allocations.set(index, cost);
-                remaining -= cost;
-            }
-            const completed = new Set(complete.map(({ index }) => index));
-            active = active.filter(({ index }) => !completed.has(index));
-        }
-        return allocations;
+        return `${ScopeFormat.region({ ...local, startLine, endLine })} of ${ScopeFormat.region(complete)}`;
     }
     static #renderLogEntries(entries, weighContent, options) {
         const bodies = entries.map((e) => {
@@ -545,20 +449,75 @@ export default class PacketWire {
             });
         });
         const visibility = entries.map((entry, index) => PacketWire.#visibleBody(entry, bodies[index]));
-        const visibleBodies = bodies.map((body, index) => ({
-            ...body,
-            content: visibility[index].fullyFolded ? "" : visibility[index].content,
-        }));
-        const promptProjectionWeights = PacketWire.#promptProjectionWeights(entries, visibleBodies, visibility, weighContent, options.promptProjectionWeight);
         return entries.map((e, index) => {
             const identity = PacketWire.#rowIdentity(e, options);
             // Parse rx once — reused for the matcher/items enrichment and the body.
             const rx = (typeof e.rx === "string" ? PacketWire.#safeParse(e.rx) : e.rx);
             const facts = PacketWire.#rowResultFacts(identity, e, rx, bodies[index]);
-            const projected = PacketWire.#rowBody(identity, e, bodies[index], visibility[index], facts, promptProjectionWeights.get(index), weighContent);
+            const projected = PacketWire.#rowBody(identity, e, bodies[index], visibility[index], facts);
             return PacketWire.#rowAccounting(identity, e, bodies[index], visibility[index], projected, weighContent, options);
         });
     }
+    static #attrsOf(e) {
+        const attrs = typeof e.attrs === "string" ? PacketWire.#safeParse(e.attrs) : e.attrs;
+        return attrs !== null && typeof attrs === "object" && !Array.isArray(attrs) ? attrs : {};
+    }
+    // One stored log row as the renderer sees it: the durable columns decoded once, a transient
+    // open row rendered open ({§invalid-emission-attempts}).
+    static entryView(r, transientOpenLogEntryId = null) {
+        const tx = (r.mimetype_tx === "application/json" ? JSON.parse(r.tx) : r.tx);
+        const rx = r.mimetype_rx === "application/json" ? JSON.parse(r.rx) : r.rx;
+        // {§context-fit} — a READ row's anchors ride with its lines whatever its status: a receipt that
+        // carries a prefix carries the prefix's anchors.
+        const readResult = LogEntryProjection.op(r) === "READ" && rx !== null && typeof rx === "object" && typeof rx.content === "string";
+        const rawLineAnchors = readResult && Object.hasOwn(rx, "lineAnchors") ? rx.lineAnchors : undefined;
+        if (rawLineAnchors !== undefined && !Array.isArray(rawLineAnchors)) {
+            throw new TypeError("A READ result's lineAnchors field must be an array.");
+        }
+        const lineAnchors = rawLineAnchors;
+        const rawLineNumberWidth = readResult && Object.hasOwn(rx, "lineNumberWidth") ? rx.lineNumberWidth : undefined;
+        if (rawLineNumberWidth !== undefined && !LineAnchors.isLineNumberWidth(rawLineNumberWidth)) {
+            throw new TypeError("A READ result's lineNumberWidth field must be a valid decimal line width.");
+        }
+        if ((rawLineAnchors === undefined) !== (rawLineNumberWidth === undefined)) {
+            throw new TypeError("A READ result's lineAnchors and lineNumberWidth fields must appear together.");
+        }
+        return {
+            id: r.id,
+            coordinate: `${r.loop_seq}/${r.turn_seq}/${r.sequence}`,
+            origin: r.origin,
+            op: r.op,
+            signal: r.signal === null ? null : JSON.parse(r.signal),
+            target: {
+                scheme: r.scheme,
+                username: r.username, password: r.password,
+                hostname: r.hostname, port: r.port,
+                pathname: r.pathname,
+                query: r.query,
+                fragment: r.fragment,
+            },
+            status: r.status_rx,
+            rx,
+            mimetype_rx: r.mimetype_rx,
+            tx,
+            mimetype_tx: r.mimetype_tx,
+            initial_folded: r.id === transientOpenLogEntryId ? LogVisibility.OPEN : LogVisibility.parse(r.initial_folded),
+            folded: LogVisibility.parse(r.folded),
+            source: r.source,
+            attrs: r.attrs === null ? null : JSON.parse(r.attrs),
+            producer: r.producer,
+            ...(lineAnchors === undefined ? {} : { lineAnchors }),
+            ...(rawLineNumberWidth === undefined ? {} : { lineNumberWidth: rawLineNumberWidth }),
+        };
+    }
+    // {§context-fit} — the tokens one row would charge the packet, rendered exactly as the log
+    // would render it, so the fit test and the gauge agree.
+    static rowTokens(view, weighContent, options = {}) {
+        const [row] = PacketWire.#renderLogEntries([view], weighContent, options);
+        if (row === undefined)
+            throw new Error("rowTokens: one view renders one row");
+        return row.curationTarget?.tokens ?? 0;
+    }
     // The row's identity and authored facts: who wrote it, what it addressed, and the statuses
     // that stay explicit. `meta` is the metadata line under construction; each later stage adds
     // to it, and {§log-wire-format}'s canonical JSON sorts the keys, so the order of stages never
@@ -639,6 +598,15 @@ export default class PacketWire {
             && typeof e.attrs.worker === "string") {
             meta.worker = e.attrs.worker;
         }
+        // {§worker-wait-timing} — the accepted bound, not elapsed time or the current configuration.
+        if (op === "WAIT" && e.attrs !== null && typeof e.attrs === "object" && "waiting" in e.attrs) {
+            const seconds = e.attrs.waiting;
+            if (typeof seconds !== "number" || !Number.isFinite(seconds) || (seconds < 0 && seconds !== -1)) {
+                throw new TypeError("A WAIT receipt carries a malformed waiting bound.");
+            }
+            if (seconds >= 0)
+                meta.waitSeconds = seconds;
+        }
         // An execution's output is a separate stream entry ({§exec-stream}); its address rides in a
         // `stream` link, distinct from the runtime-owned invocation target.
         // {§exec-target-routing} {§fs-namespace} — the receipt names the working directory only
@@ -799,23 +767,22 @@ export default class PacketWire {
             }));
             structuredMutationReceipt = effects.some((effect) => effect.receipt !== undefined);
         }
-        return { findItems, range, structuredMutationReceipt };
+        return {
+            findItems, range, structuredMutationReceipt,
+            ...(op === "READ" && rx?.matches !== undefined
+                ? { matches: SchemeResults.assertMatchEvidenceList(rx.matches) } : {}),
+        };
     }
-    // The body the row shows: the canonical full body is shared with log READ, log FIND, and
-    // search derivation. READ/FIND own selection bounds, NOTE, lifecycle bodies and admitted programs remain
-    // complete, and exterior arrivals share their packet allowance. Structured mutation receipts own
-    // their join bound; every remaining body uses the ordinary fixed preview.
-    static #rowBody(identity, e, fullBody, bodyVisibility, facts, promptProjectionWeight, weighContent) {
+    // The body the row shows: the canonical full body, shared with log READ, log FIND and search
+    // derivation, whole. Whether a result fit was decided where it landed ({§context-fit}); the packet
+    // cuts nothing but the emission head ({§emission-row}).
+    static #rowBody(identity, e, fullBody, bodyVisibility, facts) {
         const { meta, op } = identity;
         const projectedBody = {
             ...fullBody,
             content: bodyVisibility.fullyFolded ? bodyVisibility.readableContent : bodyVisibility.content,
         };
         const emptyFind = op === "FIND" && e.status === 200 && facts.findItems === 0;
-        const previewExempt = op === "READ"
-            || op === "FIND"
-            || op === "NOTE" || typeof op === "string" && TurnDisposition.isOp(op)
-            || facts.structuredMutationReceipt;
         const lineAnchors = op === "READ" ? e.lineAnchors ?? null : null;
         const lineNumberWidth = op === "READ" ? e.lineNumberWidth ?? null : null;
         if (lineAnchors !== null) {
@@ -831,18 +798,31 @@ export default class PacketWire {
         const sourceOrdinals = bodyVisibility.fullyFolded
             ? bodyVisibility.readableOrdinals
             : bodyVisibility.ordinals;
-        const projection = promptProjectionWeight !== undefined
-            ? PacketWire.#promptProjection(projectedBody, promptProjectionWeight, weighContent, (content) => PacketWire.#renderContentBody(content, bodyStartLine, null, null, numericLineNumberWidth, bodyStartLine === null
-                ? null
-                : sourceOrdinals.slice(0, TextCoordinates.logicalLines(content).length)))
-            : previewExempt
-                ? { text: projectedBody.content, cut: false, chunk: null }
-                : PacketWire.#preview(projectedBody.content);
-        const projectedLineCount = TextCoordinates.logicalLines(projection.text).length;
+        // {§markerless-first-page} — what came back unasked in size is its first page here too; what the
+        // model authored or asked for exactly, and a retrieval's own page, render whole.
+        const projection = PacketWire.#receivedBody(e, op)
+            ? PacketWire.#preview(projectedBody.content)
+            : { text: projectedBody.content, cut: false, chunk: null };
+        const projectedText = projection.text;
+        const projectedLineCount = TextCoordinates.logicalLines(projectedText).length;
         const projectedOrdinals = sourceOrdinals.slice(0, projectedLineCount);
-        const body = emptyFind || projection.text.length === 0
+        if (facts.matches !== undefined && !bodyVisibility.fullyFolded) {
+            const physicalLines = projectedOrdinals.map((ordinal) => fullBody.lineOrdinals?.[ordinal - 1]
+                ?? (fullBody.startLine ?? 1) + ordinal - 1);
+            const evidence = PatternEdits.visible(facts.matches, physicalLines).map(({ region, enclosingRegion, locator }) => ({
+                ...(locator === undefined ? {} : { locator }),
+                ...(region === undefined ? {} : { region: ScopeFormat.region(region) }),
+                ...(enclosingRegion === undefined ? {} : { enclosingRegion: ScopeFormat.region(enclosingRegion) }),
+            }));
+            if (evidence.length > 0) {
+                meta.matches = BodyPreview.items(evidence, JSON.stringify);
+                if (meta.matches.length !== evidence.length)
+                    meta.matchLocationCount = evidence.length;
+            }
+        }
+        const body = emptyFind || projectedText.length === 0
             ? ""
-            : PacketWire.#renderContentBody(projection.text, bodyStartLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, bodyStartLine === null ? null : projectedOrdinals, fullBody.lineOrdinals ?? null);
+            : PacketWire.#renderContentBody(projectedText, bodyStartLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, bodyStartLine === null ? null : projectedOrdinals, fullBody.lineOrdinals ?? null);
         // lines beside tokens on a non-retrieval row with a navigable body — the count of
         // `N:`-numbered lines (fences and unnumbered prose don't count), so the model can plan
         // a <start,end> slice before paying for a READ. READ/FIND own typed extents instead.
@@ -854,14 +834,13 @@ export default class PacketWire {
         }
         const display = bodyVisibility.readableContent.length === 0
             ? "none"
-            : bodyVisibility.fullyFolded || e.output_withheld === true
+            : bodyVisibility.fullyFolded
                 ? "folded"
                 : body.length === 0
                     ? "none"
                     : "open";
-        const projectedChunk = projection.chunk !== null
-            && bodyVisibility.folded.length > 0
-            && !bodyVisibility.fullyFolded
+        // {§packet-extent-metadata} — a page states what it shows of what the row holds.
+        const projectedChunk = projection.chunk !== null && bodyVisibility.folded.length > 0 && !bodyVisibility.fullyFolded
             ? PacketWire.#sparseChunk(fullBody.content, projectedBody.content, sourceOrdinals, projection.text)
             : projection.chunk;
         if (display === "open" && projectedChunk !== null) {
@@ -870,65 +849,70 @@ export default class PacketWire {
         }
         return { body, projectedLineCount, display };
     }
-    // The row's native attachment, its withholding receipt, and the accounting field that
+    // The row's native attachment, a landed-unfit arrival's size, and the accounting field that
     // participates in the row it measures: iterate until its decimal width and therefore the
     // rendered row's curation weight are stable. {§packet-token-accounting}
     static #rowAccounting(identity, e, fullBody, bodyVisibility, projected, weighContent, options) {
         const { meta, op, coordinate, path, target } = identity;
-        const { body, projectedLineCount, display } = projected;
+        const { body, display } = projected;
         const nativeCandidate = op === "READ" && typeof e.status === "number" && e.status >= 200 && e.status < 300
             ? PacketWire.#attachmentOf(e.rx, e.target, coordinate, target) : null;
         const native = nativeCandidate !== null && (options.acceptedAttachmentKinds?.has(nativeCandidate.kind) ?? true)
             ? nativeCandidate : null;
-        const outputWithheld = e.output_withheld === true
-            && ((!bodyVisibility.fullyFolded && body.length > 0) || native !== null);
-        if (outputWithheld) {
-            const omitted = body.length > 0
-                ? `${projectedLineCount} output lines${native === null ? "" : " and native content"}`
-                : "native content";
-            meta.overflow = `${omitted} not shown; the log exceeded logTokensMax when this row was withheld`;
-        }
-        // {§log-wire-format}: one descriptive heading, the facts, the body.
-        let logTokens = 0;
-        const renderRow = () => {
-            const lines = [`### ${path}${identity.description === null ? "" : ` ${identity.description}`} · ${logTokens}`];
-            if (Object.keys(meta).length > 0)
-                lines.push(PacketWire.#canonicalJson(meta));
-            if (display === "open")
-                lines.push(body);
-            return lines.join("\n");
-        };
+        // {§context-fit} — an arrival that did not fit landed folded with its size beside it: the lines
+        // and tokens of the body the model can READ at this row's address.
+        const unfit = PacketWire.#attrsOf(e).unfit;
+        if (unfit !== null && typeof unfit === "object")
+            meta.size = unfit;
         // {§packet-attachment-parts}: retained native content shares the row's curation lifetime.
-        const attachment = e.output_withheld !== true
-            && !(bodyVisibility.totalLines > 0 && bodyVisibility.fullyFolded)
+        const attachment = !(bodyVisibility.totalLines > 0 && bodyVisibility.fullyFolded)
             ? native
             : null;
-        if (attachment !== null)
-            meta.tokensAttachment = attachment.weight;
         // {§emission-row}: an emission row carries its frozen emission outside its record, and charges what
         // the wire delivers of it, as the worker's own message, exactly as a native part is charged.
         const emission = LogEntryProjection.isEmission(e) && coordinate !== null
             ? { coordinate, content: fullBody.content, weight: weighContent(PacketWire.deliveredEmission(fullBody.content)) }
             : null;
-        for (let pass = 0; pass < 8; pass += 1) {
-            const next = weighContent(renderRow()) + (attachment?.weight ?? 0) + (emission?.weight ?? 0);
-            if (next === logTokens) {
-                return {
-                    content: renderRow(),
-                    curationTarget: { path, logTokens },
-                    attachment,
-                    emission,
-                    unadmittedOutput: (display === "open" || attachment !== null)
-                        && fullBody.provenance === "returned"
-                        && e.output_admission_turn_id == null
-                        && typeof e.id === "number"
-                        ? e.id : null,
-                    newOverflow: outputWithheld && e.newOverflow === true,
-                };
+        // {§log-wire-format}: one descriptive heading, the facts, the body.
+        const render = (open, tokens) => {
+            const lines = [`### ${path}${identity.description === null ? "" : ` ${identity.description}`} · ${tokens}`];
+            if (Object.keys(meta).length > 0)
+                lines.push(PacketWire.#canonicalJson(meta));
+            if (open)
+                lines.push(body);
+            return lines.join("\n");
+        };
+        const converge = (open, part) => {
+            if (part !== null)
+                meta.tokensAttachment = part.weight;
+            else
+                delete meta.tokensAttachment;
+            let tokens = 0;
+            for (let pass = 0; pass < 8; pass += 1) {
+                const next = weighContent(render(open, tokens)) + (part?.weight ?? 0) + (emission?.weight ?? 0);
+                if (next === tokens)
+                    return { content: render(open, tokens), tokens };
+                tokens = next;
             }
-            logTokens = next;
-        }
-        throw new Error("packet log row accounting did not converge");
+            throw new Error("packet log row accounting did not converge");
+        };
+        const row = (rendered, part, bodied) => ({ content: rendered.content, curationTarget: { path, tokens: rendered.tokens }, attachment: part, emission, bodied });
+        const whole = converge(display === "open", attachment);
+        // {§context-own-rows-fit} — a row the wall may take carries a body or a native part and is not an
+        // emission row, whose head-cut program keeps the turn legible.
+        if (typeof e.id !== "number" || emission !== null || (display !== "open" && attachment === null))
+            return row(whole, attachment, null);
+        if (!(options.bodiless?.has(e.id) ?? false))
+            return row(whole, attachment, { id: e.id, tokens: whole.tokens });
+        // Taken: the fit rule's receipt shape — its size and address, no body, no native part.
+        meta.size = { lines: projected.projectedLineCount, tokens: whole.tokens };
+        const receipt = converge(false, null);
+        if (receipt.tokens < whole.tokens)
+            return row(receipt, null, null);
+        // A receipt that weighs no less than the body it stands for sheds nothing: the row stays whole and
+        // is spent.
+        delete meta.size;
+        return row(converge(display === "open", attachment), attachment, null);
     }
     static #attachmentOf(rx, target, coordinate, path) {
         const view = rx;