@plurnk/plurnk-service 4.2.1 → 4.3.1

package/dist/core/packet-wire.js

@@ -7,7 +7,7 @@
 // Format and omission rules are owned by {§packet-markdown}. Section producers
 // supply names and typed content; this projection preserves their ordered evidence.
 import { relative, sep } from "node:path";
-import { Problems, Validator } from "@plurnk/plurnk-contracts";
+import { Problems, Validator, isRecord, isSafeInteger, isExecutionOp } from "@plurnk/plurnk-contracts";
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
 import BodyPreview from "../content/body-preview.js";
 import { renderAuthoredTarget, renderTarget } from "./plurnk-uri.js";
@@ -21,7 +21,6 @@ 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";
-import { isExecutionOp } from "@plurnk/plurnk-contracts";
 export default class PacketWire {
     // {§packet-markdown} Render the sections in `slot` to one ChatMessage.content
     // string. Sections render in list order; empties are omitted (no empty headers on the wire);
@@ -47,17 +46,13 @@ export default class PacketWire {
     // Durable operation failures render as `{status, path}` JSON pointers to the log rows that
     // own their exact RFC 9457 results.
     static renderFailurePointers(failures) {
-        const rows = Array.isArray(failures) ? failures : [];
-        const pointers = rows
-            .filter((row) => typeof row.status === "number" && typeof row.coordinate === "string")
-            .map((row) => JSON.stringify({ status: row.status, path: `log:///${row.coordinate}` }));
+        const pointers = failures.map((row) => JSON.stringify({ status: row.status, path: `log:///${row.coordinate}` }));
         return pointers.length === 0 ? "" : `[${pointers.join(",\n")}]`;
     }
     // {§notice-callout} — non-terminal observations, deliberately separate from operation failures, in the
     // card's own callout form: the level picks the callout, the directive leads, the fact follows, the kind closes.
     static renderNotices(notices) {
-        const observations = Array.isArray(notices) ? notices : [];
-        return observations.map((notice) => {
+        return notices.map((notice) => {
             const kind = typeof notice.kind === "string" ? notice.kind : "notice";
             const callout = notice.level === "error" ? "CAUTION" : notice.level === "warn" ? "WARNING" : "NOTE";
             const text = [notice.directive, notice.message]
@@ -82,8 +77,7 @@ export default class PacketWire {
         return `{"workers":${PacketWire.#pointers(workers)},\n"streams":${PacketWire.#pointers(streams)},\n"messages":${PacketWire.#pointers(messages)}}`;
     }
     static #pointers(rows) {
-        const items = Array.isArray(rows) ? rows : [];
-        const pointers = items.map((r) => JSON.stringify({
+        const pointers = rows.map((r) => JSON.stringify({
             status: r.status,
             path: r.path,
             ...(typeof r.detail === "string" && r.detail.length > 0 ? { detail: r.detail } : {}),
@@ -97,7 +91,7 @@ export default class PacketWire {
     }
     // The git section content: the working-tree summary. "" when absent.
     static renderGit(git) {
-        const status = git === null || git === undefined ? "" : PacketWire.#renderGitState(git);
+        const status = git === null ? "" : PacketWire.#renderGitState(git);
         return status.length === 0 ? "" : `> [!NOTE]\n${status.split("\n").map((line) => `> ${line}`).join("\n")}`;
     }
     // The log section's content: the model's curated rows as Markdown-framed records ({§log-wire-format}).
@@ -109,17 +103,15 @@ export default class PacketWire {
     // {§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: [], bodied: [] };
-        const rows = PacketWire.#renderLogEntries(log, weighContent, options);
+        if (entries.length === 0)
+            return { content: "", records: [], curationTargets: [], attachments: [] };
+        const rows = PacketWire.#renderLogEntries(entries, weighContent, options);
         const records = rows.map(({ content }) => content);
         return {
             content: records.join("\n\n"),
             records,
             curationTargets: rows.flatMap(({ curationTarget }) => curationTarget === null ? [] : [curationTarget]),
             attachments: rows.flatMap(({ attachment }) => attachment === null ? [] : [attachment]),
-            bodied: rows.flatMap(({ bodied }) => bodied === null ? [] : [bodied]),
         };
     }
     // Read one section's content by name off a packet (Engine's or re-parsed).
@@ -236,7 +228,7 @@ export default class PacketWire {
     }
     // {§log-wire-format} Orientation precedes telemetry on every receipt.
     static #canonicalJson(obj) {
-        return JSON.stringify(Object.fromEntries(Object.keys(obj).sort().map((key) => [key, obj[key]])));
+        return JSON.stringify(Object.fromEntries(Object.keys(obj).toSorted().map((key) => [key, obj[key]])));
     }
     static #receiptMeta(value) {
         const receipt = assertEditReceipt(value);
@@ -317,7 +309,7 @@ export default class PacketWire {
         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";
+        return isRecord(attrs) && 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,
@@ -412,7 +404,8 @@ export default class PacketWire {
         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 parsedRx = typeof e.rx === "string" ? PacketWire.#safeParse(e.rx) : e.rx;
+            const rx = isRecord(parsedRx) ? parsedRx : null;
             const facts = PacketWire.#rowResultFacts(identity, e, rx, bodies[index]);
             const paired = options.paired?.has(String(e.coordinate)) ?? false;
             const projected = paired && bodies[index].provenance === "authored"
@@ -423,22 +416,23 @@ export default class PacketWire {
     }
     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 : {};
+        return isRecord(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 parsedTx = r.mimetype_tx === "application/json" ? JSON.parse(r.tx) : r.tx;
+        const tx = isRecord(parsedTx) ? parsedTx : typeof parsedTx === "string" ? parsedTx : null;
         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 readResult = LogEntryProjection.op(r) === "READ" && isRecord(rx) && typeof rx.content === "string" ? rx : null;
+        const rawLineAnchors = readResult !== null && Object.hasOwn(readResult, "lineAnchors") ? readResult.lineAnchors : undefined;
+        if (rawLineAnchors !== undefined && !(Array.isArray(rawLineAnchors) && rawLineAnchors.every((anchor) => typeof anchor === "string"))) {
+            throw new TypeError("A READ result's lineAnchors field must be an array of strings.");
         }
         const lineAnchors = rawLineAnchors;
-        const rawLineNumberWidth = readResult && Object.hasOwn(rx, "lineNumberWidth") ? rx.lineNumberWidth : undefined;
+        const rawLineNumberWidth = readResult !== null && Object.hasOwn(readResult, "lineNumberWidth") ? readResult.lineNumberWidth : undefined;
         if (rawLineNumberWidth !== undefined && !LineAnchors.isLineNumberWidth(rawLineNumberWidth)) {
             throw new TypeError("A READ result's lineNumberWidth field must be a valid decimal line width.");
         }
@@ -502,16 +496,16 @@ export default class PacketWire {
         // subsystem token when present; absence means the owning worker.
         // {§message-short-identity} an arrival whose source is the transport's own name for it adds
         // nothing to its address; a peer's or an agent's source still shows.
-        const arrivalAttrs = typeof e.attrs === "string" ? PacketWire.#safeParse(e.attrs) : e.attrs;
-        const selfAddressed = arrivalAttrs !== null && typeof arrivalAttrs === "object" && arrivalAttrs.selfAddressed === true;
+        const attrs = PacketWire.#attrsOf(e);
+        const selfAddressed = attrs.selfAddressed === true;
         if (typeof e.source === "string" && e.source.length > 0 && !selfAddressed)
             meta.source = e.source;
         // {§message-causal-source}: every other sender has an address; the operator's message is named
         // for the model, or it reads as the model's own SEND.
         if (PacketWire.isArrival(e) && meta.source === undefined)
             meta.origin = "user";
-        if (e.source === "file" && e.attrs !== null && typeof e.attrs === "object" && "git" in e.attrs) {
-            const git = e.attrs.git;
+        if (e.source === "file" && Object.hasOwn(attrs, "git")) {
+            const git = attrs.git;
             if (typeof git !== "string" || git.length !== 2) {
                 throw new TypeError("A source=file log row carries malformed Git XY metadata.");
             }
@@ -520,19 +514,20 @@ export default class PacketWire {
         // {§log-wire-format}: routine success is implicit, independently of the operation.
         if (typeof e.status === "number" && e.status !== 200)
             meta.status = e.status;
-        const tx = (typeof e.tx === "string" ? PacketWire.#safeParse(e.tx) : e.tx);
+        const parsedTx = typeof e.tx === "string" ? PacketWire.#safeParse(e.tx) : e.tx;
+        const tx = isRecord(parsedTx) ? parsedTx : null;
         const replay = options.paired?.get(String(e.coordinate));
         const paired = replay !== undefined;
         if (!paired && typeof tx?.aside === "string")
             meta.aside = tx.aside;
-        const authored = tx?.target;
-        const target = PacketWire.#operandPath(e.target ?? authored, options.projectRoot ?? null, authored ?? null);
+        const authored = PacketWire.#authoredPath(tx?.target);
+        const target = PacketWire.#operandPath(e.target ?? PacketWire.#actionTarget(tx?.target), options.projectRoot ?? null, authored);
         const pair = op === "COPY" || op === "MOVE";
         const selections = pair
-            ? [tx?.source, tx?.destination]
+            ? [PacketWire.#selection(tx?.source), PacketWire.#selection(tx?.destination)]
             : [{ ...tx, target: e.target ?? tx?.target }];
-        const paths = selections.map((selection) => PacketWire.#operandPath(selection?.target, options.projectRoot ?? null, authored ?? null));
-        if (pair && typeof e.status === "number" && e.status < 400 && paths.some((path) => path === null)) {
+        const paths = selections.map((selection) => PacketWire.#operandPath(PacketWire.#actionTarget(selection?.target), options.projectRoot ?? null, authored));
+        if (pair && typeof e.status === "number" && e.status < 400 && paths.some((candidate) => candidate === null)) {
             throw new Error(`A successful ${op} log row must retain both operand selections.`);
         }
         for (const field of ["scope", "metadata"]) {
@@ -540,45 +535,39 @@ export default class PacketWire {
                 continue;
             const values = selections.map((selection) => field === "scope"
                 ? PacketWire.#requestScope(selection?.lineMarker)
-                : selection?.metadata?.length ? selection.metadata : null);
+                : PacketWire.#metadata(selection?.metadata));
             if (pair) {
-                const paired = Object.fromEntries(values.flatMap((value, index) => value === null ? [] : [[index === 0 ? "from" : "to", value]]));
-                if (Object.keys(paired).length > 0)
-                    meta[field] = paired;
+                const pairedValues = Object.fromEntries(values.flatMap((value, index) => value === null ? [] : [[index === 0 ? "from" : "to", value]]));
+                if (Object.keys(pairedValues).length > 0)
+                    meta[field] = pairedValues;
             }
             else if (values[0] !== null)
                 meta[field] = values[0];
         }
         // {§log-wire-format}: describe resources and patterns directly; never serialize an OP.
         const parts = selections.flatMap((selection, index) => {
-            const pattern = selection?.matcher?.raw;
+            const matcher = selection?.matcher;
+            const pattern = isRecord(matcher) ? matcher.raw : undefined;
             return [
                 ...(paths[index] === null ? [] : [`→ ${paths[index]}`]),
                 ...(typeof pattern !== "string" || pattern.length === 0 ? []
                     : [/[\r\n]/u.test(pattern) ? JSON.stringify(pattern) : pattern]),
             ];
         });
-        const request = replay?.statement;
-        const requestedSelections = request === undefined ? [] : request.op === "COPY" || request.op === "MOVE"
-            ? [request.source, request.destination] : [request];
-        const resolved = paired && paths.some((path, index) => {
-            const selection = requestedSelections[index];
-            const requested = selection !== undefined && "target" in selection ? selection.target : null;
-            return path !== PacketWire.#operandPath(requested, options.projectRoot ?? null, requested);
-        });
+        // {§paired-receipt}: every receipt names its operand; a paired one leaves its pattern to the replayed operation.
+        const operands = paths.filter((candidate) => candidate !== null).map((candidate) => `→ ${candidate}`).join(" ");
         const description = op === "error" || op === "extension" || parts.length === 0 ? null
-            : !paired ? parts.join(" ") : resolved ? paths.filter((path) => path !== null).map((path) => `→ ${path}`).join(" ") : null;
+            : !paired ? parts.join(" ") : operands.length > 0 ? operands : null;
         // {§worker-auto-name} The created identity is an outcome, not an authored target.
-        if ((op === "WORK" || op === "FORK") && e.attrs !== null && typeof e.attrs === "object"
-            && typeof e.attrs.worker === "string") {
-            meta.worker = e.attrs.worker;
+        if ((op === "WORK" || op === "FORK") && typeof attrs.worker === "string") {
+            meta.worker = attrs.worker;
             // {§worker-scheme-spawn} — a WORK that reached a worker the name already held says so.
-            if (e.attrs.delivered === "message")
+            if (attrs.delivered === "message")
                 meta.delivered = "message";
         }
         // {§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 (op === "WAIT" && Object.hasOwn(attrs, "waiting")) {
+            const seconds = attrs.waiting;
             if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) {
                 throw new TypeError("A WAIT receipt carries a malformed waiting bound.");
             }
@@ -588,21 +577,21 @@ export default class PacketWire {
         // `stream` link, distinct from the runtime-owned invocation target.
         // {§exec-target-routing} {§fs-namespace} — the receipt names the working directory only
         // when it is not the project root, and then in project-relative form.
-        if (isExecutionOp(op) && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.cwd === "string") {
-            const cwd = PacketWire.#projectRelativeCwd(e.attrs.cwd, options.projectRoot ?? null);
+        if (isExecutionOp(op) && typeof attrs.cwd === "string") {
+            const cwd = PacketWire.#projectRelativeCwd(attrs.cwd, options.projectRoot ?? null);
             if (cwd !== null)
                 meta.cwd = cwd;
         }
-        if (isExecutionOp(op) && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.stream === "string") {
-            meta.stream = e.attrs.stream;
+        if (isExecutionOp(op) && typeof attrs.stream === "string") {
+            meta.stream = attrs.stream;
         }
         return { meta, op, tx, coordinate, path, renderedLeaf, target, description };
     }
-    // The row's result facts from its rx: the terminal stream's exit, the Problem or detail, the
-    // matcher, the retrieval extents, and the structured mutation receipts. Returns what the body
-    // projection needs to know about the result.
+    // The row's result facts from its rx, added to the metadata line stage by stage: the attachments and the
+    // returned address, the terminal stream's exit, the Problem or detail, the retrieval extents, and the
+    // structured mutation receipts. Returns what the body projection needs to know about the result.
     static #rowResultFacts(identity, e, rx, fullBody) {
-        const { meta, op, tx } = identity;
+        const { meta, op } = identity;
         if (op === "SEND" && rx !== null && typeof rx === "object" && Array.isArray(rx.attachments) && rx.attachments.length > 0) {
             meta.attachments = rx.attachments.map(({ name, mediaType, target }) => ({ name, mediaType, path: target }));
         }
@@ -611,8 +600,19 @@ export default class PacketWire {
             && rx.resource.length > 0 && rx.resource !== identity.target && rx.resource !== meta.stream) {
             meta.resource = rx.resource;
         }
-        // {§exec-stream}: explicit and automatic READs preserve the same
-        // durable liveness facts, including an empty active channel.
+        PacketWire.#streamReadFacts(meta, op, rx);
+        PacketWire.#problemFacts(identity, e, rx);
+        const { findItems, range } = PacketWire.#retrievalFacts(identity, e, rx, fullBody);
+        const structuredMutationReceipt = PacketWire.#mutationReceiptFacts(meta, op, rx);
+        return {
+            findItems, range, structuredMutationReceipt,
+            ...(op === "READ" && rx?.matches !== undefined
+                ? { matches: SchemeResults.assertMatchEvidenceList(rx.matches) } : {}),
+        };
+    }
+    // {§exec-stream}: explicit and automatic READs preserve the same
+    // durable liveness facts, including an empty active channel.
+    static #streamReadFacts(meta, op, rx) {
         if (op === "READ" && rx !== null && typeof rx === "object" && Object.hasOwn(rx, "terminal")) {
             if (typeof rx.terminal !== "boolean") {
                 throw new TypeError("A stream READ result carries a malformed terminal flag.");
@@ -627,36 +627,39 @@ export default class PacketWire {
             // {§executor-page-receipt} — a producer's full-page fact survives projection as written.
             if (Object.hasOwn(rx, "page")) {
                 const page = rx.page;
-                if (page === null || typeof page !== "object" || !Number.isSafeInteger(page.size) || !Number.isSafeInteger(page.returned)) {
+                if (!isRecord(page) || !isSafeInteger(page.size) || !isSafeInteger(page.returned)) {
                     throw new TypeError("A stream READ result carries a malformed page.");
                 }
                 meta.page = { size: page.size, returned: page.returned };
             }
         }
-        // {§problem-projection} — the exact durable Problem remains the
-        // failure authority; the packet carries only facts not already
-        // owned by its enclosing row. Errors remains only an index.
+    }
+    // {§problem-projection} — the exact durable Problem remains the
+    // failure authority; the packet carries only facts not already
+    // owned by its enclosing row. Errors remains only an index.
+    // The success-side sibling (#342): a sub-problem receipt may carry one
+    // terse `detail` (e.g. the EDIT 304) so situational teaching is paid
+    // only when the situation occurs, never in the hot path.
+    static #problemFacts(identity, e, rx) {
+        const { meta } = identity;
         if (typeof e.status === "number" && e.status >= 400 && rx !== null && typeof rx === "object") {
-            const problem = rx.problem;
-            Validator.assertProblemDetails(problem);
+            const problem = Validator.assertProblemDetails(rx.problem);
             meta.problem = Problems.project(problem, {
                 status: e.status,
                 row: { ...meta, target: identity.target },
             });
         }
-        // The success-side sibling (#342): a sub-problem receipt may carry one
-        // terse `detail` (e.g. the EDIT 304) so situational teaching is paid
-        // only when the situation occurs, never in the hot path.
-        if (!Object.hasOwn(meta, "problem") && rx !== null && typeof rx === "object"
-            && typeof rx.detail === "string"
-            && rx.detail.length > 0) {
+        if (!Object.hasOwn(meta, "problem") && rx !== null && typeof rx.detail === "string" && rx.detail.length > 0) {
             meta.detail = rx.detail;
         }
-        // {§retrieval-packet-metadata}: one extent/coordinate owner plus
-        // only FIND aggregates that add information beyond that extent.
+    }
+    // {§retrieval-packet-metadata}: one extent/coordinate owner plus
+    // only FIND aggregates that add information beyond that extent.
+    static #retrievalFacts(identity, e, rx, fullBody) {
+        const { meta, op, tx } = identity;
         let findItems = null;
         let range = null;
-        const patterned = tx !== null && tx !== undefined && typeof tx === "object" && tx.matcher !== null && typeof tx.matcher === "object" && typeof tx.matcher.raw === "string";
+        const patterned = tx !== null && tx !== undefined && typeof tx === "object" && isRecord(tx.matcher) && typeof tx.matcher.raw === "string";
         if (patterned && op !== "FIND" && rx !== null && typeof rx === "object" && typeof rx.matched === "number")
             meta.matched = rx.matched;
         // {§channel-selection-visibility} — a READ names the resource's other channels with their
@@ -677,13 +680,10 @@ export default class PacketWire {
             range = rx !== null && typeof rx === "object" && rx.range !== undefined
                 ? Validator.assertRangeExtent(rx.range)
                 : null;
-            const problemOwnsRange = typeof e.status === "number"
-                && e.status >= 400
-                && meta.problem !== null
-                && typeof meta.problem === "object"
-                && Object.hasOwn(meta.problem, "range");
+            const problem = isRecord(meta.problem) ? meta.problem : null;
+            const problemOwnsRange = typeof e.status === "number" && e.status >= 400 && problem !== null && Object.hasOwn(problem, "range");
             if (problemOwnsRange) {
-                Validator.assertRangeExtent(meta.problem.range);
+                Validator.assertRangeExtent(problem?.range);
                 delete meta.scope;
             }
             if (range !== null && !problemOwnsRange) {
@@ -722,9 +722,12 @@ export default class PacketWire {
                 meta.matchLocationCount = rx.matchLocationCount;
             }
         }
-        // {§edit-result-receipt-projection} {§edit-result-copy-move-effects}
-        // EDIT/scoped entry KILL own one receipt; COPY/MOVE own resource effects whose
-        // optional receipts describe scoped textual materializations.
+        return { findItems, range };
+    }
+    // {§edit-result-receipt-projection} {§edit-result-copy-move-effects}
+    // EDIT/scoped entry KILL own one receipt; COPY/MOVE own resource effects whose
+    // optional receipts describe scoped textual materializations.
+    static #mutationReceiptFacts(meta, op, rx) {
         let structuredMutationReceipt = false;
         if ((op === "EDIT" || op === "KILL") && rx !== null && typeof rx === "object" && Object.hasOwn(rx, "receipt")) {
             Object.assign(meta, PacketWire.#receiptMeta(rx.receipt));
@@ -744,11 +747,7 @@ export default class PacketWire {
             }));
             structuredMutationReceipt = effects.some((effect) => effect.receipt !== undefined);
         }
-        return {
-            findItems, range, structuredMutationReceipt,
-            ...(op === "READ" && rx?.matches !== undefined
-                ? { matches: SchemeResults.assertMatchEvidenceList(rx.matches) } : {}),
-        };
+        return structuredMutationReceipt;
     }
     // 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}).
@@ -791,8 +790,9 @@ export default class PacketWire {
                 ...(enclosingRegion === undefined ? {} : { enclosingRegion: ScopeFormat.region(enclosingRegion) }),
             }));
             if (evidence.length > 0) {
-                meta.matches = BodyPreview.items(evidence, JSON.stringify);
-                if (meta.matches.length !== evidence.length)
+                const shown = BodyPreview.items(evidence, JSON.stringify);
+                meta.matches = shown;
+                if (shown.length !== evidence.length)
                     meta.matchLocationCount = evidence.length;
             }
         }
@@ -823,7 +823,7 @@ export default class PacketWire {
             meta.preview = projectedChunk;
             delete meta.lines;
         }
-        return { body, projectedLineCount, display };
+        return { body, display };
     }
     // 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
@@ -867,52 +867,35 @@ export default class PacketWire {
             }
             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, 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 folded record carries no body.
-        if (typeof e.id !== "number" || LogEntryProjection.isEmission(e) || (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);
+        const rendered = converge(display === "open", attachment);
+        return { content: rendered.content, curationTarget: { path, tokens: rendered.tokens }, attachment };
     }
     static #attachmentOf(rx, target, coordinate, path) {
-        const view = rx;
-        const contentHash = rx?.nativeContentHash;
-        if (typeof contentHash !== "string")
+        if (!isRecord(rx) || typeof rx.nativeContentHash !== "string")
             return null;
+        const contentHash = rx.nativeContentHash;
         const pathname = typeof target?.pathname === "string" && target.pathname.length > 0
             ? target.pathname
             : typeof target?.raw === "string" ? target.raw : null;
         if (pathname === null || coordinate === null || path === null)
             return null;
         const scheme = target?.scheme ?? "file";
-        const image = view?.image;
-        if (image !== undefined && typeof image.mimetype === "string" && Number.isSafeInteger(image.width) && Number.isSafeInteger(image.height)) {
-            const width = image.width;
-            const height = image.height;
+        const image = rx.image;
+        if (isRecord(image) && typeof image.mimetype === "string" && isSafeInteger(image.width) && isSafeInteger(image.height)) {
+            const { width, height } = image;
             return { contentHash, coordinate, path, scheme, pathname, mimetype: image.mimetype, kind: "image", width, height, weight: imageWeight(width, height) };
         }
-        const document = view?.document;
-        if (document !== undefined && typeof document.mimetype === "string" && Number.isSafeInteger(document.bytes)) {
-            const pages = Number.isSafeInteger(document.pages) ? document.pages : null;
+        const document = rx.document;
+        if (isRecord(document) && typeof document.mimetype === "string" && isSafeInteger(document.bytes)) {
+            const pages = isSafeInteger(document.pages) ? document.pages : null;
             return {
                 contentHash, coordinate, path, scheme, pathname, mimetype: document.mimetype, kind: "pdf",
                 ...(pages === null ? {} : { pages }),
                 weight: pdfWeight(pages, document.bytes),
             };
         }
-        const audio = view?.audio;
-        if (audio !== undefined && typeof audio.mimetype === "string" && Number.isSafeInteger(audio.bytes)) {
+        const audio = rx.audio;
+        if (isRecord(audio) && typeof audio.mimetype === "string" && isSafeInteger(audio.bytes)) {
             const duration = typeof audio.duration === "number" && Number.isFinite(audio.duration) && audio.duration >= 0 ? audio.duration : null;
             return {
                 contentHash, coordinate, path, scheme, pathname, mimetype: audio.mimetype, kind: "audio",
@@ -943,7 +926,7 @@ export default class PacketWire {
                 const parts = [];
                 for (const [at, section] of sections.entries()) {
                     parts.push({ type: "text", text: `${at === 0 ? "" : "\n\n"}${PacketWire.renderSection(section)}` });
-                    for (const attachment of attachments.filter((attachment) => attachment.section === section.name)) {
+                    for (const attachment of attachments.filter((candidate) => candidate.section === section.name)) {
                         parts.push({ type: "text", text: `\n\n${PacketWire.attachmentCaption(attachment)}` });
                         parts.push({ type: "file", data: await bytesOf(attachment), mediaType: attachment.mimetype });
                     }
@@ -1011,15 +994,54 @@ export default class PacketWire {
     static #requestScope(marker) {
         if (marker === null || marker === undefined)
             return null;
-        const marks = marker.marks;
-        if (!Array.isArray(marks) || marks.some((mark) => typeof mark !== "string" && typeof mark !== "number")) {
+        const marks = isRecord(marker) ? marker.marks : undefined;
+        const isMark = (mark) => typeof mark === "string" || typeof mark === "number";
+        if (!Array.isArray(marks) || !marks.every(isMark)) {
             throw new TypeError("An operation scope must retain its authored marks.");
         }
+        const [first, ...rest] = marks;
+        if (first === undefined)
+            throw new TypeError("An operation scope must retain its authored marks.");
         // Failed selections still describe what was attempted; the operation owns validity.
-        return ScopeFormat.marker(marker);
+        return ScopeFormat.marker({ marks: [first, ...rest] });
+    }
+    // {§packet-stored-shape} A stored operand target: the address columns as nullable strings, the port a number, the
+    // authored `kind` and `raw` read where used. A field of another type is a malformed row.
+    static #actionTarget(value) {
+        if (value === null || value === undefined)
+            return null;
+        if (!isRecord(value))
+            throw new TypeError("A stored operand target must be an object.");
+        const text = (name) => {
+            const field = value[name];
+            if (field === undefined || field === null || typeof field === "string")
+                return field;
+            throw new TypeError(`A stored operand target carries a malformed ${name}.`);
+        };
+        const port = value.port;
+        if (port !== undefined && port !== null && typeof port !== "number") {
+            throw new TypeError("A stored operand target carries a malformed port.");
+        }
+        return {
+            kind: value.kind, raw: value.raw, scheme: text("scheme"), hostname: text("hostname"), port, pathname: text("pathname"),
+            query: text("query"), fragment: text("fragment"), username: text("username"), password: text("password"),
+        };
+    }
+    // The target as the model authored it, when the stored statement's target is a path the grammar names; a row
+    // whose stored target is not renders without its authored spelling.
+    static #authoredPath(value) {
+        if (value === null || value === undefined)
+            return null;
+        return Validator.validateParsedPath(value).valid ? Validator.assertParsedPath(value) : null;
+    }
+    static #selection(value) {
+        return isRecord(value) ? value : null;
+    }
+    static #metadata(value) {
+        return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string") ? value : null;
     }
     // {§packet-git-status}: the count line, then one bounded line per non-empty class. Untracked paths are
-    // named because they are NOT members ({§membership-baseline}) — a human `git add`s or picks them.
+    // named because they are NOT members ({§membership-baseline}) — the user admits them.
     static #renderGitState(git) {
         const sync = git.ahead > 0 || git.behind > 0 ? ` (↑${git.ahead} ↓${git.behind})` : "";
         const position = git.branch === null ? "detached HEAD" : `branch \`${git.branch}\`${git.unborn ? " (no commits)" : ""}`;