@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/cli/render/contract.js

@@ -1,6 +1,6 @@
 import { renderAcceptedAudit } from "./audit.js";
 import { appendHookPayload, executionCleanupLines, executionStopLines, hookFailureSummary, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
-import { gitShortStat, renderOpaqueBlock } from "./terminal.js";
+import { renderOpaqueBlock, safeText, tone } from "./terminal.js";
 const HANG = "  ";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14,23 +14,19 @@ function retryLines(detail, indent, columns) {
 function lagRows(lag, columns) {
     const lines = [];
     if (lag.kind === "worktree-retained") {
-        receiptRow(lines, "!", "lag", [{ text: `worktree-retained ${lag.path}`, opaque: true }], columns);
+        receiptRow(lines, "!", "lag", [{ text: "worktree retained" }, { text: lag.path, opaque: true }], columns);
     }
     else if (lag.kind === "worktree-follow-retained") {
         receiptRow(lines, "!", "lag", [
-            {
-                text: `${lag.kind} reason ${lag.reason} tender ${lag.tender} head ${lag.head}${lag.paths === undefined || lag.paths.length === 0 ? "" : ` paths ${lag.paths.join(",")}`} path ${lag.path}`,
-                opaque: true,
-            },
+            { text: "worktree follow retained" },
+            { text: "·" },
+            { text: lag.reason.replaceAll("-", " ") },
+            { text: "·" },
+            { text: lag.path, opaque: true },
         ], columns);
     }
     else if (lag.kind === "unsealed-bytes") {
-        receiptRow(lines, "!", "lag", [
-            {
-                text: `unsealed-bytes ${lag.path}${lag.head === undefined ? "" : ` head ${lag.head}`}${lag.paths.length === 0 ? "" : ` paths ${lag.paths.join(",")}`}`,
-                opaque: true,
-            },
-        ], columns);
+        receiptRow(lines, "!", "lag", [{ text: "unsealed bytes" }, { text: lag.path, opaque: true }], columns);
     }
     else if (lag.kind === "target-checkout-retained") {
         receiptRow(lines, "!", "lag", [{ text: `target-checkout-retained ${lag.target} ${lag.path}`, opaque: true }], columns);
@@ -57,39 +53,43 @@ function lagRows(lag, columns) {
 }
 function settlementLagRows(lag, columns) {
     const lines = [];
-    receiptRow(lines, "!", "settlement", [
-        {
-            text: [
-                `surface ${lag.surface}`,
-                lag.taskId === undefined ? undefined : `task ${lag.taskId}`,
-                lag.path === undefined ? undefined : `path ${lag.path}`,
-            ]
-                .filter((part) => part !== undefined)
-                .join(" "),
-            opaque: true,
-        },
-    ], columns);
+    receiptRow(lines, "!", "settlement", [{ text: lag.surface.replaceAll("-", " ") }], columns);
+    if (lag.taskId !== undefined)
+        receiptRow(lines, " ", "task", [{ text: lag.taskId, opaque: true }], columns);
+    if (lag.path !== undefined)
+        receiptRow(lines, " ", "path", [{ text: lag.path, opaque: true }], columns);
     receiptPayload(lines, "diagnostic", lag.diagnostic);
     return lines;
 }
-function workspaceRows(workspace, columns) {
-    const lines = [];
-    receiptRow(lines, " ", "workspace", [{ text: gitShortStat(workspace.shortStat) }], columns);
-    for (const name of ["staged", "unstaged", "untracked"]) {
-        for (const path of workspace[name]) {
-            receiptRow(lines, " ", name, [{ text: path, opaque: true }], columns);
+function overlapRows(overlaps, color) {
+    const groups = new Map();
+    for (const overlap of overlaps) {
+        let patterns = groups.get(overlap.contract);
+        if (patterns === undefined) {
+            patterns = new Map();
+            groups.set(overlap.contract, patterns);
         }
+        for (const pattern of overlap.patterns)
+            patterns.set(JSON.stringify([pattern.mine, pattern.theirs]), pattern);
     }
-    return lines;
-}
-function overlapRows(overlaps, columns) {
-    const lines = [];
-    for (const overlap of overlaps) {
-        for (const pattern of overlap.patterns) {
-            receiptRow(lines, " ", "overlap", [
-                { text: overlap.contract, opaque: true },
-                { text: `${pattern.mine} ~ ${pattern.theirs}`, opaque: true },
-            ], columns);
+    if (groups.size === 0)
+        return [];
+    const lines = ["", `  ${tone("overlap", "dim", color)}`];
+    for (const [contract, patterns] of groups) {
+        if (lines.length > 2)
+            lines.push("");
+        const identity = safeText(contract);
+        lines.push(`  ${tone("└─", "dim", color)} ${color ? `\u001b[1m${identity}\u001b[0m` : identity}`);
+        let first = true;
+        for (const { mine, theirs } of patterns.values()) {
+            if (mine === theirs)
+                lines.push(`       ${safeText(mine)}`);
+            else {
+                if (!first)
+                    lines.push("");
+                lines.push(`       this   ${safeText(mine)}`, `       other  ${safeText(theirs)}`);
+            }
+            first = false;
         }
     }
     return lines;
@@ -101,19 +101,6 @@ function pushBlock(lines, block) {
 }
 function acceptedRecord(result, columns) {
     const record = [];
-    for (const fact of result.facts) {
-        const contract = fact.contract === result.contract ? [] : [{ text: fact.contract, opaque: true }];
-        receiptRow(record, " ", "journal", fact.kind === "reintegrated"
-            ? [
-                ...contract,
-                { text: fact.entry, opaque: true },
-                { text: "· reintegrated" },
-                { text: fact.data.predecessor, opaque: true },
-                { text: "->" },
-                { text: fact.data.snapshot, opaque: true },
-            ]
-            : [...contract, { text: fact.entry, opaque: true }, { text: `· ${fact.kind}` }], columns);
-    }
     if (result.recoverySnapshot !== undefined)
         receiptRow(record, " ", "recovery snapshot", [{ text: result.recoverySnapshot, opaque: true }], columns);
     if (result.verb === "deliver") {
@@ -134,25 +121,10 @@ function acceptedLagRows(result, columns) {
     pushBlock(obligations, executionStopLines(result.executionStops ?? [], columns));
     return obligations;
 }
-function indentRecord(lines) {
-    let payload = false;
-    return lines.map((line) => {
-        if (line.length === 0) {
-            payload = !payload;
-            return line;
-        }
-        return payload ? line : `  ${line}`;
-    });
-}
-function acceptedDeviations(result, columns) {
+function acceptedDeviations(result, columns, color) {
     const deviations = [];
-    if (result.verb === "review") {
-        if (result.workspace !== undefined)
-            pushBlock(deviations, workspaceRows(result.workspace, columns));
-        return deviations;
-    }
     if (result.overlaps !== undefined)
-        pushBlock(deviations, overlapRows(result.overlaps, columns));
+        pushBlock(deviations, overlapRows(result.overlaps, color));
     if (result.overlapFailure !== undefined) {
         receiptRow(deviations, "!", "overlap", [{ text: "unavailable" }], columns);
         receiptPayload(deviations, "diagnostic", result.overlapFailure);
@@ -161,29 +133,57 @@ function acceptedDeviations(result, columns) {
 }
 function recordBlock(result, columns) {
     const rows = [...acceptedRecord(result, columns), ...acceptedLagRows(result, columns)];
-    return ["  record", ...indentRecord(rows)];
+    return rows;
 }
-function completionLines(result, columns) {
+function nonGatingVerificationLines(result, columns) {
     const lines = [];
+    const verification = result.completion?.verification;
+    if (verification === undefined || verification.verdict !== "unsatisfied")
+        return lines;
+    receiptRow(lines, "!", "verification", [{ text: "unsatisfied" }, { text: `(${verification.mode})` }, { text: "· not required by Contract gates" }], columns);
+    if (result.verificationSummary !== undefined) {
+        receiptPayload(lines, "  summary", result.verificationSummary);
+    }
+    return lines;
+}
+function shortGitId(value) {
+    return /^[0-9a-f]{40}$/iu.test(value) ? value.slice(0, 7) : value;
+}
+/**
+ * Shared presentation of a completed placement, so a deliver and a review that placed the same candidate read
+ * identically: one git-shaped target movement row, naming the reference it advanced, then the final lifecycle
+ * state. Satisfied Verification adds one fact row naming the commit the verdict ran against; placement made that
+ * commit the reference's new head, so the two rows share one sha. Verification mode words stay in JSON and
+ * `history`, never in ordinary receipt text. A completion without an advanced reference states no movement.
+ * Journal ULIDs stay in JSON and `history`, never in ordinary receipt text.
+ */
+function completedPlacementLines(result, columns) {
     const completion = result.completion;
     if (completion === undefined)
-        return lines;
-    const verification = completion.verification;
-    receiptRow(lines, " ", "target", [
-        { text: "->" },
-        { text: completion.integration, opaque: true },
-        ...(verification !== undefined && "verdict" in verification && verification.verdict === "satisfied"
-            ? [{ text: `· verified (${verification.mode})` }]
-            : []),
-    ], columns);
-    if (verification !== undefined && "verdict" in verification && verification.verdict === "unsatisfied") {
-        receiptRow(lines, "!", "verification", [{ text: "unsatisfied" }, { text: `(${verification.mode})` }, { text: "· not required by Contract gates" }], columns);
-        if (result.verificationSummary !== undefined) {
-            receiptPayload(lines, "  summary", result.verificationSummary);
-        }
+        return [];
+    const lines = [];
+    if (completion.predecessor !== undefined && completion.target !== undefined) {
+        receiptRow(lines, " ", "target", [
+            { text: `${shortGitId(completion.predecessor)}..${shortGitId(completion.integration)}` },
+            { text: completion.target, opaque: true },
+        ], columns);
     }
+    if (completion.verification?.verdict === "satisfied") {
+        receiptRow(lines, " ", "verification", [{ text: "satisfied" }, { text: `· on ${shortGitId(completion.integration)}` }], columns);
+    }
+    lines.push(...nonGatingVerificationLines(result, columns));
+    // Placement admission always admits the claim entry beside the movement, so a completed placement is claimed.
+    receiptRow(lines, "●", "claimed", [], columns);
     return lines;
 }
+/** Evidence handles stay in JSON and history; ordinary receipt text carries only outstanding obligations. */
+function obligationLines(result, columns) {
+    const rows = [];
+    if (result.recoverySnapshot !== undefined)
+        receiptRow(rows, " ", "recovery snapshot", [{ text: result.recoverySnapshot, opaque: true }], columns);
+    rows.push(...acceptedLagRows(result, columns));
+    return rows;
+}
 function movementLines(result, columns) {
     const count = result.facts.filter((fact) => fact.kind === "reintegrated").length;
     if (count === 0)
@@ -213,7 +213,7 @@ function continuationLines(result, columns) {
     }
     return lines;
 }
-function renderAcceptedBind(result, columns) {
+function renderAcceptedBind(result, columns, color) {
     const lines = titleLines("✓", "bound", result.contract, columns);
     if (result.workspace !== undefined)
         receiptRow(lines, " ", "workspace", [{ text: "worktree" }, { text: result.workspace.path, opaque: true }], columns);
@@ -221,27 +221,34 @@ function renderAcceptedBind(result, columns) {
         receiptRow(lines, " ", "no target", [], columns);
     else
         receiptRow(lines, " ", "target", [{ text: result.target, opaque: true }], columns);
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    for (const warning of result.warnings ?? [])
+        receiptRow(lines, "!", "region warning", [{ text: warning }], columns);
+    lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
-function renderAcceptedAmend(result, columns) {
-    const lines = titleLines("✓", "terms replaced", result.contract, columns);
-    receiptPayload(lines, "  terms diff", result.diff);
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+function renderAcceptedAmend(result, columns, color) {
+    const changed = result.diff.length > 0;
+    const lines = titleLines("✓", changed ? "terms replaced" : "terms unchanged", result.contract, columns);
+    if (changed)
+        receiptPayload(lines, "  terms diff", result.diff);
+    lines.push(...acceptedDeviations(result, columns, color), ...recordBlock(result, columns));
     return lines.join("\n");
 }
 function renderAcceptedDeliver(result, columns) {
     const complete = result.completion !== undefined;
-    const title = complete ? "delivered" : "deliver — not complete";
+    const title = complete ? "delivered" : "deliver incomplete";
     const lines = titleLines("✓", title, result.contract, columns);
     if (result.leading !== undefined) {
-        receiptRow(lines, " ", "leading", [{ text: result.leading.kind }, { text: result.leading.fact, opaque: true }], columns);
+        receiptRow(lines, " ", "leading", [{ text: result.leading.kind.replaceAll("-", " ") }], columns);
     }
     if (result.tenderSnapshot !== undefined)
         receiptRow(lines, " ", "tender commit", [{ text: result.tenderSnapshot, opaque: true }], columns);
     if (result.integration !== undefined)
         receiptRow(lines, " ", "content identity (not commit)", [{ text: result.integration.changeId, opaque: true }], columns);
-    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
+    if (complete)
+        lines.push(...completedPlacementLines(result, columns));
+    else
+        lines.push(...movementLines(result, columns));
     if (result.verification !== undefined) {
         lines.push(...stopLines(result.verification, columns, result.contract));
     }
@@ -251,16 +258,12 @@ function renderAcceptedDeliver(result, columns) {
     if (!complete)
         receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
     lines.push(...continuationLines(result, columns));
-    lines.push(...recordBlock(result, columns));
+    lines.push(...(complete ? obligationLines(result, columns) : recordBlock(result, columns)));
     return lines.join("\n");
 }
 function renderAcceptedReview(result, columns) {
-    const lines = titleLines("✓", `review ${result.verdict} recorded`, result.contract, columns);
-    lines.push(...movementLines(result, columns), ...completionLines(result, columns));
-    if (result.completion !== undefined) {
-        receiptRow(lines, " ", "placement", [{ text: "complete" }], columns);
-        receiptRow(lines, " ", "integration commit", [{ text: result.completion.integration, opaque: true }], columns);
-    }
+    const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
+    lines.push(...completedPlacementLines(result, columns));
     if (result.verification !== undefined) {
         lines.push(...stopLines(result.verification, columns, result.contract));
     }
@@ -268,11 +271,11 @@ function renderAcceptedReview(result, columns) {
         lines.push(...stopLines(result.placement, columns, result.contract));
     }
     lines.push(...continuationLines(result, columns));
-    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    lines.push(...obligationLines(result, columns));
     return lines.join("\n");
 }
 function renderAcceptedArc(result, columns) {
-    const lines = titleLines("✓", "chapter recorded", result.contract, columns);
+    const lines = titleLines("✓", `entered chapter ${result.chapter.seq}`, result.contract, columns);
     receiptRow(lines, " ", "chapter", [{ text: String(result.chapter.seq) }, { text: "·" }, { text: result.chapter.title }], columns);
     lines.push(...recordBlock(result, columns));
     return lines.join("\n");
@@ -290,9 +293,9 @@ export function renderAccepted(result, context) {
         case "audit":
             return renderAcceptedAudit(result, context);
         case "bind":
-            return renderAcceptedBind(result, columns);
+            return renderAcceptedBind(result, columns, context?.color === true);
         case "amend":
-            return renderAcceptedAmend(result, columns);
+            return renderAcceptedAmend(result, columns, context?.color === true);
         case "review":
             return renderAcceptedReview(result, columns);
         case "arc":

package/build/src/cli/render/execution-progress.d.ts

@@ -1,4 +1,26 @@
 import type { ExecutionEvent } from "../../library/execution.js";
 import { type TextRenderContext } from "./terminal.js";
-/** Render one witnessed execution event for the CLI's ephemeral stderr stream. */
+import { type StatusLineOptions, type StatusLineStream } from "./status-line.js";
+/** Sparse rendering for consumers that do not own a live stream. */
 export declare function executionProgressLines(event: ExecutionEvent, context: TextRenderContext): readonly string[];
+export type ExecutionProgressOptions = StatusLineOptions & Readonly<{
+    stream: StatusLineStream;
+    context: TextRenderContext;
+}>;
+/** Consumes witnessed events into either a live TTY line or sparse text. */
+export declare class ExecutionProgressRenderer {
+    private readonly input;
+    private readonly status;
+    private verificationStartedAt;
+    private declarations;
+    private declarationFailed;
+    private phaseFailed;
+    private phaseUnknown;
+    constructor(input: ExecutionProgressOptions);
+    consume(event: ExecutionEvent): Promise<void>;
+    finish(): void;
+    private consumeVerification;
+    private write;
+    private finalMark;
+}
+export declare function renderExecutionProgress(events: AsyncIterable<ExecutionEvent>, input: ExecutionProgressOptions): Promise<void>;

package/build/src/cli/render/execution-progress.js

@@ -1,4 +1,5 @@
 import { renderOpaqueBlock, safeText } from "./terminal.js";
+import { StatusLine } from "./status-line.js";
 const LIVE_OUTPUT_BYTES = 4 * 1024;
 function boundedUtf8Prefix(value) {
     let bytes = 0;
@@ -12,44 +13,166 @@ function boundedUtf8Prefix(value) {
     }
     return { text, truncated: false };
 }
-function phaseCoordinates(observation) {
-    return [
-        ...(observation.cwd === undefined ? [] : [`cwd=${safeText(observation.cwd)}`]),
-        ...(observation.source === undefined ? [] : [`source=${safeText(observation.source)}`]),
-        ...(observation.name === undefined ? [] : [`hook=${safeText(observation.name)}`]),
-        ...(observation.index === undefined ? [] : [`declaration=${observation.index}/${observation.total ?? "?"}`]),
-    ];
+function elapsed(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1_000));
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m${seconds % 60}s`;
+}
+function phaseDetail(observation) {
+    if (observation.phase === "declaration")
+        return `declaration ${observation.index ?? "?"}/${observation.total ?? "?"}`;
+    return observation.name === undefined ? observation.phase : `${observation.phase} · ${safeText(observation.name)}`;
+}
+function phaseStartLine(observation) {
+    return `● ${[phaseDetail(observation), ...(observation.cwd === undefined ? [] : [safeText(observation.cwd)])].join(" · ")}`;
+}
+function phaseMark(outcome) {
+    if (outcome === undefined)
+        return "?";
+    return outcome === "ok" || outcome === "exit 0" ? "✓" : "×";
 }
-function renderVerification(event, context) {
-    const observation = event.observation;
-    const coordinates = phaseCoordinates(observation);
-    if (observation.kind === "output") {
-        const output = boundedUtf8Prefix(observation.text);
-        return [
-            `• verification ${observation.phase} ${observation.stream}${coordinates.length === 0 ? "" : `  ${coordinates.join(" ")}`}`,
-            ...renderOpaqueBlock(output.text, "  ", context.columns),
-            ...(output.truncated ? [`  [live output truncated at ${LIVE_OUTPUT_BYTES} bytes]`] : []),
-        ];
-    }
-    const details = [
-        ...coordinates,
-        ...(observation.outcome === undefined ? [] : [`outcome=${safeText(observation.outcome)}`]),
-        ...(observation.elapsedMs === undefined ? [] : [`elapsed=${Math.round(observation.elapsedMs)}ms`]),
+function phaseFinishLine(observation) {
+    const facts = [
+        phaseDetail(observation),
+        ...(observation.elapsedMs === undefined ? [] : [elapsed(observation.elapsedMs)]),
     ];
+    if (observation.outcome !== undefined && observation.outcome !== "ok" && observation.outcome !== "exit 0")
+        facts.push(safeText(observation.outcome));
+    return `${phaseMark(observation.outcome)} ${facts.join(" · ")}`;
+}
+function outputLines(observation, context) {
+    const output = boundedUtf8Prefix(observation.text);
     return [
-        `• verification ${observation.phase} ${observation.state}${details.length === 0 ? "" : `  ${details.join(" ")}`}`,
+        observation.stream,
+        ...renderOpaqueBlock(output.text, "  ", context.columns),
+        ...(output.truncated ? ["  [live output truncated]"] : []),
     ];
 }
-/** Render one witnessed execution event for the CLI's ephemeral stderr stream. */
+/** Sparse rendering for consumers that do not own a live stream. */
 export function executionProgressLines(event, context) {
     switch (event.kind) {
         case "admitted":
-            return [`• admitted ${event.fact.kind}  ${event.contractId}`];
+            return [`✓ admitted ${event.fact.kind} · ${event.contractId}`];
         case "verification":
-            return renderVerification(event, context);
+            return event.observation.kind === "output"
+                ? outputLines(event.observation, context)
+                : [
+                    event.observation.state === "started"
+                        ? phaseStartLine(event.observation)
+                        : phaseFinishLine(event.observation),
+                ];
         case "stage":
-            return [`• ${event.stage} ${event.state}  ${event.contractId}`];
+            return [`${event.state === "started" ? "●" : "✓"} ${event.stage}`];
         case "progress-dropped":
-            return [`• progress dropped ${event.count} event${event.count === 1 ? "" : "s"}`];
+            return [`progress dropped ${event.count} event${event.count === 1 ? "" : "s"}`];
+    }
+}
+/** Consumes witnessed events into either a live TTY line or sparse text. */
+export class ExecutionProgressRenderer {
+    input;
+    status;
+    verificationStartedAt;
+    declarations;
+    declarationFailed = false;
+    phaseFailed = false;
+    phaseUnknown = false;
+    constructor(input) {
+        this.input = input;
+        this.status = new StatusLine(input.stream, input);
+    }
+    async consume(event) {
+        if (event.kind === "verification") {
+            await this.consumeVerification(event);
+            return;
+        }
+        await this.write(executionProgressLines(event, this.input.context));
     }
+    finish() {
+        if (!this.status.isTTY || this.verificationStartedAt === undefined)
+            return;
+        const now = this.input.now ?? (() => performance.now());
+        const duration = elapsed(now() - this.verificationStartedAt);
+        if (this.declarations !== undefined) {
+            const { passed, total } = this.declarations;
+            this.status.finish(`verify  ${this.finalMark()} ${passed}/${total} · ${duration}`);
+            return;
+        }
+        this.status.finish(`verify  ${this.finalMark()} · ${duration}`);
+    }
+    async consumeVerification(event) {
+        const observation = event.observation;
+        if (observation.kind === "output") {
+            await this.write(outputLines(observation, this.input.context));
+            return;
+        }
+        if (observation.state === "started") {
+            this.verificationStartedAt ??= (this.input.now ?? (() => performance.now()))();
+            if (this.status.isTTY)
+                this.status.show((duration) => `verify  ● ${phaseDetail(observation)} · ${elapsed(duration)}`);
+            else
+                await this.write([phaseStartLine(observation)]);
+            return;
+        }
+        const mark = phaseMark(observation.outcome);
+        this.phaseFailed ||= mark === "×";
+        this.phaseUnknown ||= mark === "?";
+        if (observation.phase === "declaration") {
+            const total = observation.total ?? this.declarations?.total ?? 0;
+            const passed = (this.declarations?.passed ?? 0) + (mark === "✓" ? 1 : 0);
+            this.declarations = { passed, total };
+            this.declarationFailed ||= mark !== "✓";
+        }
+        if (this.status.isTTY)
+            this.status.show((duration) => `verify  ${mark} ${phaseDetail(observation)} · ${elapsed(duration)}`);
+        else
+            await this.write([phaseFinishLine(observation)]);
+    }
+    write(lines) {
+        if (this.status.isTTY) {
+            this.status.writeBlock(lines);
+            return Promise.resolve();
+        }
+        return writeChunk(this.input.stream, `${lines.join("\n")}\n`);
+    }
+    finalMark() {
+        return this.phaseFailed || this.declarationFailed ? "×" : this.phaseUnknown ? "?" : "✓";
+    }
+}
+export async function renderExecutionProgress(events, input) {
+    const renderer = new ExecutionProgressRenderer(input);
+    const destination = watchDestination(input.stream);
+    const iterator = events[Symbol.asyncIterator]();
+    try {
+        for (;;) {
+            const next = await Promise.race([iterator.next(), destination.promise]);
+            if (next.done === true)
+                break;
+            await renderer.consume(next.value);
+        }
+        renderer.finish();
+    }
+    finally {
+        destination.detach();
+    }
+}
+/** Reject when the destination dies while the producer is still owned. */
+function watchDestination(stream) {
+    let detach = () => undefined;
+    const promise = new Promise((_, reject) => {
+        const onError = (error) => reject(error);
+        const onClose = () => reject(Object.assign(new Error("write on prematurely closed destination"), { code: "ERR_STREAM_PREMATURE_CLOSE" }));
+        stream.once("error", onError);
+        stream.once("close", onClose);
+        detach = () => {
+            stream.off("error", onError);
+            stream.off("close", onClose);
+        };
+    });
+    promise.catch(() => undefined);
+    return { promise, detach };
+}
+/** Await one destination write: backpressure and error propagation in one callback. */
+function writeChunk(stream, text) {
+    return new Promise((resolve, reject) => {
+        stream.write(text, (error) => (error ? reject(error) : resolve()));
+    });
 }