@giovannijecha/jecode 0.7.3 → 0.8.0

package/dist/providers/anthropic-wire.js

@@ -44,27 +44,39 @@ export function stopNotice(data) {
 export function fromWireResponse(data) {
     const raw = Array.isArray(data.content) ? data.content : [];
     const content = [];
+    let suppressedToolCall = false;
     for (const item of raw) {
         const block = item;
         if (block.type === "text" && typeof block.text === "string") {
             content.push({ kind: "text", text: block.text });
         }
-        else if (block.type === "tool_use" &&
-            typeof block.id === "string" &&
-            typeof block.name === "string") {
-            content.push({
-                kind: "tool_call",
-                id: block.id,
-                name: block.name,
-                input: (block.input ?? {}),
-            });
+        else if (block.type === "tool_use") {
+            if (data.stop_reason === "tool_use" &&
+                typeof block.id === "string" &&
+                typeof block.name === "string") {
+                content.push({
+                    kind: "tool_call",
+                    id: block.id,
+                    name: block.name,
+                    input: (block.input ?? {}),
+                });
+            }
+            else {
+                suppressedToolCall = true;
+            }
         }
         // thinking / redacted_thinking and anything future: carried in `raw` only.
     }
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: "anthropic", usage: normalizeUsage(data) };
+    const retainRaw = data.stop_reason !== "max_tokens" && !suppressedToolCall;
+    return {
+        role: "assistant",
+        content,
+        ...(retainRaw ? { raw, rawFrom: "anthropic" } : {}),
+        usage: normalizeUsage(data),
+    };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/providers/http.js

@@ -1,6 +1,7 @@
 // The entire HTTP layer: one bounded request, then either a JSON body or an
 // event stream. Only idempotent reads retry. Once a POST starts or response
 // bytes flow, a failure is surfaced rather than silently replayed.
+import { leadingText } from "../text-boundary.js";
 import { readSseJson } from "./sse.js";
 import { sseStreamCharacterLimit } from "./stream-limits.js";
 const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504]);
@@ -31,7 +32,7 @@ async function asJson(url, res) {
         return JSON.parse(text);
     }
     catch {
-        throw httpError(`${url} returned non-JSON`, res.status, text.slice(0, 500));
+        throw httpError(`${url} returned non-JSON`, res.status, leadingText(text, 500));
     }
 }
 export async function postSse(url, headers, body, maxOutputTokens, signal, onStatus) {
@@ -107,13 +108,13 @@ async function boundedText(url, res, max) {
             if (done) {
                 text += decoder.decode();
                 return text.length > max
-                    ? { text: text.slice(0, max), truncated: true }
+                    ? { text: leadingText(text, max), truncated: true }
                     : { text, truncated: false };
             }
             text += decoder.decode(value, { stream: true });
             if (text.length > max) {
                 await reader.cancel().catch(() => undefined);
-                return { text: text.slice(0, max), truncated: true };
+                return { text: leadingText(text, max), truncated: true };
             }
         }
     }

package/dist/providers/ollama-stream.js

@@ -6,6 +6,7 @@
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 export async function assembleOllama(events, onStream) {
     const calls = new Map();
+    const announcedTools = new Map();
     let toolArgumentChars = 0;
     let content = "";
     let reasoning = "";
@@ -53,6 +54,12 @@ export async function assembleOllama(events, onStream) {
                 call.args += part.function.arguments;
             }
             calls.set(index, call);
+            const name = call.name === "" ? undefined : call.name;
+            if (!announcedTools.has(index) ||
+                (announcedTools.get(index) === undefined && name !== undefined)) {
+                announcedTools.set(index, name);
+                onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+            }
         }
     }
     if (finishReason === undefined) {

package/dist/providers/ollama-wire.js

@@ -60,10 +60,18 @@ export function fromWireReply(reply) {
     const content = [];
     if (reply.content !== "")
         content.push({ kind: "text", text: reply.content });
-    for (const call of reply.toolCalls) {
-        content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+    const acceptsToolCalls = reply.finishReason === "tool_calls";
+    if (acceptsToolCalls) {
+        for (const call of reply.toolCalls) {
+            content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+        }
     }
-    const raw = reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
+    const notice = stopNotice(reply);
+    if (notice !== undefined)
+        content.push({ kind: "text", text: notice });
+    const suppressedToolCall = reply.toolCalls.length > 0 && !acceptsToolCalls;
+    const retainRaw = reply.finishReason !== "length" && !suppressedToolCall;
+    const raw = !retainRaw || reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
     return {
         role: "assistant",
         content,

package/dist/providers/openai-codex.js

@@ -152,8 +152,6 @@ function modelContextWindow(entry) {
         return undefined;
     const percent = percentage(entry["effective_context_window_percent"]) ?? 95;
     const tokens = Math.floor(resolved * percent / 100);
-    if (!validTokenCount(tokens))
-        return undefined;
     const automatic = Math.floor(resolved * 9 / 10);
     const advertised = tokenCount(entry["auto_compact_token_limit"]);
     return Object.freeze({

package/dist/providers/openai-stream.js

@@ -6,6 +6,7 @@
 // those streamed items remain the fallback when the final envelope is empty.
 export async function assembleOpenAI(events, onStream) {
     const items = [];
+    const announcedTools = { identities: new Set(), anonymous: false };
     let refusal = false;
     for await (const raw of events) {
         const event = raw;
@@ -24,14 +25,31 @@ export async function assembleOpenAI(events, onStream) {
                 if (typeof event.delta === "string")
                     onStream?.({ kind: "thinking", text: event.delta });
                 break;
+            case "response.output_item.added":
+                if (isFunctionCall(event.item)) {
+                    announceTool(event, event.item, announcedTools, onStream);
+                }
+                break;
+            case "response.function_call_arguments.delta":
+            case "response.function_call_arguments.done":
+                announceTool(event, undefined, announcedTools, onStream);
+                break;
             case "response.output_item.done":
-                if (event.item !== undefined)
+                if (event.item !== undefined) {
+                    if (isFunctionCall(event.item)) {
+                        announceTool(event, event.item, announcedTools, onStream);
+                    }
                     items.push(event.item);
+                }
                 break;
             case "response.done":
             case "response.completed":
+                return withDefaultStatus(reconcileOutput(event.response, items), "completed");
             case "response.incomplete":
-                return reconcileOutput(event.response, items);
+                return {
+                    ...reconcileOutput(event.response, items),
+                    status: "incomplete",
+                };
             case "response.failed": {
                 const response = event.response;
                 throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
@@ -44,9 +62,46 @@ export async function assembleOpenAI(events, onStream) {
     }
     throw new Error("openai stream ended before a terminal response event");
 }
+function isFunctionCall(item) {
+    return typeof item === "object" && item !== null &&
+        item["type"] === "function_call";
+}
+function announceTool(event, item, announced, onStream) {
+    const identities = toolIdentities(event, item);
+    if (identities.length === 0) {
+        if (announced.anonymous)
+            return;
+        announced.anonymous = true;
+    }
+    else {
+        const duplicate = identities.some((identity) => announced.identities.has(identity));
+        for (const identity of identities)
+            announced.identities.add(identity);
+        if (duplicate)
+            return;
+    }
+    const rawName = item?.name ?? event.name;
+    const name = typeof rawName === "string" && rawName !== "" ? rawName : undefined;
+    onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+}
+function toolIdentities(event, item) {
+    const identities = [];
+    const itemId = event.item_id ?? item?.id;
+    if (typeof itemId === "string" && itemId !== "")
+        identities.push(`item:${itemId}`);
+    if (typeof event.output_index === "number")
+        identities.push(`output:${event.output_index}`);
+    if (typeof item?.call_id === "string" && item.call_id !== "") {
+        identities.push(`call:${item.call_id}`);
+    }
+    return identities;
+}
 function reconcileOutput(completed, items) {
     if (completed === undefined)
         return { output: items };
     const finalCount = Array.isArray(completed.output) ? completed.output.length : 0;
     return items.length > finalCount ? { ...completed, output: items } : completed;
 }
+function withDefaultStatus(response, status) {
+    return response.status === undefined ? { ...response, status } : response;
+}

package/dist/providers/openai-wire.js

@@ -40,8 +40,9 @@ export function toWireItems(message, providerId = "openai") {
 }
 export function stopNotice(data) {
     const reason = data.incomplete_details?.reason;
-    if (reason === undefined)
-        return undefined;
+    if (reason === undefined) {
+        return data.status === "incomplete" ? "[incomplete response]" : undefined;
+    }
     return reason === "max_output_tokens"
         ? "[truncated: hit max_output_tokens — raise --max-tokens]"
         : `[incomplete: ${reason}]`;
@@ -49,6 +50,7 @@ export function stopNotice(data) {
 export function fromWireResponse(data, providerId = "openai") {
     const raw = Array.isArray(data.output) ? data.output : [];
     const content = [];
+    let suppressedFunctionCall = false;
     for (const entry of raw) {
         const item = entry;
         if (item.type === "message" && Array.isArray(item.content)) {
@@ -62,22 +64,35 @@ export function fromWireResponse(data, providerId = "openai") {
                 }
             }
         }
-        else if (item.type === "function_call" &&
-            typeof item.call_id === "string" &&
-            typeof item.name === "string") {
-            content.push({
-                kind: "tool_call",
-                id: item.call_id,
-                name: item.name,
-                input: parseArguments(item.arguments),
-            });
+        else if (item.type === "function_call") {
+            if (data.status === "completed" &&
+                (item.status === undefined || item.status === "completed") &&
+                typeof item.call_id === "string" &&
+                typeof item.name === "string") {
+                content.push({
+                    kind: "tool_call",
+                    id: item.call_id,
+                    name: item.name,
+                    input: parseArguments(item.arguments),
+                });
+            }
+            else {
+                suppressedFunctionCall = true;
+            }
         }
         // reasoning items and anything future: carried in `raw` only.
     }
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: providerId, usage: normalizeUsage(data) };
+    return {
+        role: "assistant",
+        content,
+        ...(data.status === "completed" && !suppressedFunctionCall
+            ? { raw, rawFrom: providerId }
+            : {}),
+        usage: normalizeUsage(data),
+    };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/providers/sse.js

@@ -7,37 +7,26 @@ import { addBounded, MAX_SSE_EVENT_CHARS, } from "./stream-limits.js";
 export async function* readSseJson(body, maximumChars) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    let buffer = "";
+    const parser = new SseEventParser();
     let finished = false;
     let total = 0;
-    const append = (text) => {
-        total = addBounded(total, text.length, maximumChars, "SSE stream");
-        buffer += text;
-    };
     try {
         for (;;) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            append(decoder.decode(value, { stream: true }));
-            for (;;) {
-                const boundary = findBoundary(buffer);
-                if (boundary === undefined)
-                    break;
-                assertEventSize(boundary.start);
-                const chunk = buffer.slice(0, boundary.start);
-                buffer = buffer.slice(boundary.end);
-                const payload = parseData(chunk);
-                if (payload !== undefined)
-                    yield payload;
-            }
-            assertEventSize(buffer.length);
+            const text = decoder.decode(value, { stream: true });
+            total = addBounded(total, text.length, maximumChars, "SSE stream");
+            for (const payload of parser.push(text))
+                yield payload;
         }
         // A stream that ends without a trailing blank line still owes us its last
         // event.
-        append(decoder.decode());
-        assertEventSize(buffer.length);
-        const payload = parseData(buffer);
+        const text = decoder.decode();
+        total = addBounded(total, text.length, maximumChars, "SSE stream");
+        for (const payload of parser.push(text))
+            yield payload;
+        const payload = parser.finish();
         if (payload !== undefined)
             yield payload;
         finished = true;
@@ -48,28 +37,116 @@ export async function* readSseJson(body, maximumChars) {
         reader.releaseLock();
     }
 }
+// Keep fragments in bounded groups. A provider may split one SSE line into
+// hundreds of thousands of tiny chunks; repeatedly flattening the growing line
+// would make parsing quadratic even if boundary scanning itself were linear.
+class TextParts {
+    #groups = [];
+    #pieces = [];
+    #lastCodeUnit = "";
+    length = 0;
+    append(text) {
+        if (text === "")
+            return;
+        this.#pieces.push(text);
+        this.#lastCodeUnit = text.at(-1);
+        this.length += text.length;
+        if (this.#pieces.length >= 256)
+            this.#flush();
+    }
+    take() {
+        this.#flush();
+        const text = this.#groups.length === 1 ? this.#groups[0] : this.#groups.join("");
+        this.#groups.length = 0;
+        this.#lastCodeUnit = "";
+        this.length = 0;
+        return text;
+    }
+    endsWithCarriageReturn() {
+        return this.#lastCodeUnit === "\r";
+    }
+    #flush() {
+        if (this.#pieces.length === 0)
+            return;
+        this.#groups.push(this.#pieces.length === 1 ? this.#pieces[0] : this.#pieces.join(""));
+        this.#pieces = [];
+    }
+}
+export class SseEventParser {
+    #line = new TextParts();
+    #data = [];
+    #eventLength = 0;
+    #hasLine = false;
+    #pendingTerminatorLength = 0;
+    *push(text) {
+        let start = 0;
+        for (;;) {
+            const newline = text.indexOf("\n", start);
+            if (newline === -1) {
+                this.#line.append(text.slice(start));
+                this.#assertPendingLineSize();
+                return;
+            }
+            this.#line.append(text.slice(start, newline));
+            const rawLine = this.#line.take();
+            const crlf = rawLine.endsWith("\r");
+            const line = crlf ? rawLine.slice(0, -1) : rawLine;
+            if (line === "") {
+                const payload = this.#finishEvent();
+                if (payload !== undefined)
+                    yield payload;
+            }
+            else {
+                this.#appendLine(line, crlf ? 2 : 1);
+            }
+            start = newline + 1;
+        }
+    }
+    finish() {
+        const line = this.#line.take();
+        if (line !== "") {
+            this.#appendLine(line, 0);
+        }
+        else if (this.#hasLine) {
+            // A single trailing line terminator is part of an unterminated event.
+            assertEventSize(this.#eventLength + this.#pendingTerminatorLength);
+        }
+        return this.#finishEvent();
+    }
+    #appendLine(line, terminatorLength) {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        assertEventSize(this.#eventLength + separatorLength + line.length);
+        this.#eventLength += separatorLength + line.length;
+        this.#hasLine = true;
+        this.#pendingTerminatorLength = terminatorLength;
+        if (line.startsWith("data:")) {
+            this.#data.push(line.slice("data:".length).trimStart());
+        }
+    }
+    #assertPendingLineSize() {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        const remaining = MAX_SSE_EVENT_CHARS - this.#eventLength - separatorLength;
+        // One trailing CR may turn out to be part of a split CRLF terminator.
+        const splitCrlf = this.#line.length === remaining + 1 && this.#line.endsWithCarriageReturn();
+        if (this.#line.length > remaining && !splitCrlf) {
+            assertEventSize(MAX_SSE_EVENT_CHARS + 1);
+        }
+    }
+    #finishEvent() {
+        const data = this.#data.join("\n");
+        this.#data = [];
+        this.#eventLength = 0;
+        this.#hasLine = false;
+        this.#pendingTerminatorLength = 0;
+        return parseData(data);
+    }
+}
 function assertEventSize(length) {
     if (length > MAX_SSE_EVENT_CHARS) {
         throw new Error(`SSE event exceeded ${MAX_SSE_EVENT_CHARS} characters`);
     }
 }
-// Handles both LF and CRLF framing without normalising the buffer first — a
-// normalising pass would have to cope with a \r\n split across two chunks.
-function findBoundary(buffer) {
-    const lf = buffer.indexOf("\n\n");
-    const crlf = buffer.indexOf("\r\n\r\n");
-    if (lf === -1 && crlf === -1)
-        return undefined;
-    if (crlf !== -1 && (lf === -1 || crlf < lf))
-        return { start: crlf, end: crlf + 4 };
-    return { start: lf, end: lf + 2 };
-}
-function parseData(chunk) {
-    const data = chunk
-        .split(/\r?\n/)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice("data:".length).trimStart())
-        .join("\n");
+function parseData(data) {
     if (data === "" || data === "[DONE]")
         return undefined;
     try {

package/dist/sessions/codec.js

@@ -3,7 +3,7 @@
 // can become conversation or provider input.
 import { Buffer } from "node:buffer";
 import { CONTEXT_LIMITS } from "../context/projection.js";
-export const SESSION_SCHEMA = 3;
+export const SESSION_SCHEMA = 4;
 export const SESSION_FILE_LIMITS = Object.freeze({
     text: 1_048_576,
     metadataBytes: 64 * 1_024,
@@ -135,7 +135,7 @@ export function decodeNode(value) {
             effort: identity["effort"],
         }),
         messages: Object.freeze(messages.map(messageFromRecord)),
-        blocks: Object.freeze(blocks.map(blockFromRecord)),
+        blocks: Object.freeze(blocks.map((block) => blockFromRecord(block, version))),
         ...(context === undefined ? {} : { context: Object.freeze(context) }),
         ...(failure === undefined ? {} : { failure: Object.freeze(failure) }),
     });
@@ -266,18 +266,23 @@ function blockRecord(block) {
             right: block.right,
             tone: block.tone,
             body: block.body?.map(detailRecord) ?? null,
+            durationMs: block.durationMs ?? null,
         }];
 }
-function blockFromRecord(value) {
+function blockFromRecord(value, version) {
     if (!record(value) || typeof value["kind"] !== "string")
         throw invalid();
     if ((value["kind"] === "user" || value["kind"] === "answer" || value["kind"] === "reasoning") &&
         keys(value, "kind,text") && boundedText(value["text"]))
         return { kind: value["kind"], text: value["text"] };
-    if (value["kind"] === "tool" && keys(value, "body,kind,name,right,target,tone") &&
+    const toolKeys = version >= 4
+        ? "body,durationMs,kind,name,right,target,tone"
+        : "body,kind,name,right,target,tone";
+    if (value["kind"] === "tool" && keys(value, toolKeys) &&
         bounded(value["name"], 256) && boundedText(value["target"]) &&
         boundedText(value["right"], 1_024) &&
         (value["tone"] === "ok" || value["tone"] === "fail" || value["tone"] === "deny") &&
+        (version < 4 || nullableInteger(value["durationMs"], 0)) &&
         (value["body"] === null ||
             (Array.isArray(value["body"]) && value["body"].length <= SESSION_FILE_LIMITS.details))) {
         const body = value["body"] === null
@@ -290,6 +295,9 @@ function blockFromRecord(value) {
             right: value["right"],
             tone: value["tone"],
             ...(body === undefined ? {} : { body }),
+            ...(version < 4 || value["durationMs"] === null
+                ? {}
+                : { durationMs: value["durationMs"] }),
         };
     }
     throw invalid();
@@ -398,7 +406,7 @@ function integer(value, minimum) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
 }
 function schema(value) {
-    return value === 1 || value === 2 || value === SESSION_SCHEMA;
+    return value === 1 || value === 2 || value === 3 || value === SESSION_SCHEMA;
 }
 function settlement(value, version) {
     return value === "checkpointed" || value === "completed" ||

package/dist/sessions/store.js

@@ -8,6 +8,7 @@ import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename
 import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
+import { leadingText } from "../text-boundary.js";
 import { userDataPath } from "../user-data.js";
 import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_FILE_LIMITS, SESSION_SCHEMA, } from "./codec.js";
 import { leaseOwner, leaseToken, pidIsAlive, removeLease, sessionLease, } from "./lease.js";
@@ -367,7 +368,7 @@ function firstUserText(conversation) {
         const text = message.content.find((block) => block.kind === "text")?.text
             .replace(/\s+/gu, " ").trim();
         if (text !== undefined && text !== "")
-            return text.slice(0, 160);
+            return leadingText(text, 160);
     }
     return "Untitled session";
 }

package/dist/settings-command.js

@@ -41,9 +41,6 @@ export async function settingsCommand(session, host) {
             case "maxTokens":
                 await numberSetting(session, host, "maxTokens", "max output tokens");
                 break;
-            case "maxSteps":
-                await numberSetting(session, host, "maxSteps", "max tool steps");
-                break;
             case "compactionPercent":
                 await compactionSetting(session, host);
                 break;
@@ -81,7 +78,6 @@ function settingsItems(values) {
                     action: "maxTokens",
                     option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
-        { action: "maxSteps", option: { label: "max tool steps", value: String(values.maxSteps) } },
         {
             action: "compactionPercent",
             option: { label: "context compaction", value: `${values.compactionPercent}%` },
@@ -102,7 +98,6 @@ function settingsValues(session) {
         model: session.model,
         effort: session.config.effort,
         ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
-        maxSteps: session.config.maxSteps,
         compactionPercent: session.config.compactionPercent,
         reducedMotion: session.config.reducedMotion,
     };

package/dist/settings.js

@@ -59,7 +59,6 @@ function normalize(value) {
     const effort = member(value["effort"], EFFORTS);
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
-    const maxSteps = positiveInteger(value["maxSteps"]);
     const compactionPercent = percentage(value["compactionPercent"]);
     return {
         ...(provider === undefined ? {} : { provider }),
@@ -68,7 +67,6 @@ function normalize(value) {
         ...(effort === undefined ? {} : { effort }),
         ...(reducedMotion === undefined ? {} : { reducedMotion }),
         ...(maxTokens === undefined ? {} : { maxTokens }),
-        ...(maxSteps === undefined ? {} : { maxSteps }),
         ...(compactionPercent === undefined ? {} : { compactionPercent }),
     };
 }

package/dist/steering.js

@@ -0,0 +1,58 @@
+// A bounded cooperative inbox for guidance submitted during an active turn.
+export const MAX_STEERING_MESSAGES = 8;
+export const MAX_STEERING_CODE_UNITS = 32_768;
+/**
+ * Build one inbox for one model turn. `drainOrClose` is the atomic completion
+ * handshake: pending guidance keeps the turn open; an empty queue closes it
+ * before the final checkpoint so late input cannot disappear.
+ */
+export function steeringInbox(changed = () => { }) {
+    let accepting = true;
+    let codeUnits = 0;
+    const messages = [];
+    const take = () => {
+        if (messages.length === 0)
+            return [];
+        const drained = messages.splice(0);
+        codeUnits = 0;
+        changed(0, accepting);
+        return drained;
+    };
+    return {
+        offer(text) {
+            if (!accepting)
+                return "closed";
+            if (messages.length >= MAX_STEERING_MESSAGES ||
+                codeUnits + text.length > MAX_STEERING_CODE_UNITS)
+                return "full";
+            messages.push(text);
+            codeUnits += text.length;
+            changed(messages.length, true);
+            return "queued";
+        },
+        drain: take,
+        drainOrClose() {
+            if (messages.length > 0)
+                return { messages: take(), closed: false };
+            accepting = false;
+            changed(0, false);
+            return { messages: [], closed: true };
+        },
+        close() {
+            if (!accepting && messages.length === 0)
+                return [];
+            accepting = false;
+            if (messages.length === 0) {
+                changed(0, false);
+                return [];
+            }
+            return take();
+        },
+        get pending() {
+            return messages.length;
+        },
+        get accepting() {
+            return accepting;
+        },
+    };
+}