@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/codeAgent/agent/CodeAgentEventMapper.ts

@@ -0,0 +1,225 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import {
+  type CodeAgentEventBody,
+  type CodeAgentStopReason,
+  type CodeAgentToolOp,
+  type CodeAgentToolSummary,
+  codeAgentClip,
+  codeAgentLabelChars,
+  codeAgentOutputChars,
+} from "akanjs/common";
+import { stringArg } from "./stringArg";
+
+const toolOps: { [key: string]: CodeAgentToolOp } = {
+  read: "read",
+  write: "write",
+  edit: "write",
+  ls: "list",
+  find: "search",
+  grep: "search",
+  bash: "execute",
+};
+
+// A turn is one prompt: the engine's `turn_start` fires per LLM round trip, so `agent_start`/`agent_end` bound it.
+export class CodeAgentEventMapper {
+  #turn = 0;
+  #turnId = "";
+  #outcome: CodeAgentStopReason | undefined;
+  readonly #openTools = new Map<string, CodeAgentToolSummary>();
+  readonly #blocked = new Map<string, string>();
+
+  get turnId() {
+    return this.#turnId;
+  }
+
+  map(event: AgentSessionEvent): CodeAgentEventBody[] {
+    switch (event.type) {
+      case "agent_start":
+        this.#turn += 1;
+        this.#turnId = `t${this.#turn}`;
+        // A hint left by an abort that hit an idle session must not colour the turn after it.
+        this.#outcome = undefined;
+        return [{ type: "turn_start", turnId: this.#turnId }];
+      case "agent_end":
+        // `turn_end` is last by contract; the engine finalizes the message before the run ends, even on abort.
+        return [
+          ...this.flushBlocked(),
+          { type: "turn_end", turnId: this.#turnId, stopReason: this.#stopReason(event) },
+        ];
+      case "agent_settled":
+        return [{ type: "idle" }];
+      case "message_update":
+        return this.#mapDelta(event);
+      case "message_end":
+        return this.#mapMessage(event);
+      case "tool_execution_start": {
+        const tool = this.#summary(event.toolCallId, event.toolName, event.args);
+        this.#openTools.set(event.toolCallId, tool);
+        return [{ type: "tool_start", turnId: this.#turnId, tool }];
+      }
+      case "tool_execution_update":
+        return [
+          {
+            type: "tool_progress",
+            turnId: this.#turnId,
+            toolCallId: event.toolCallId,
+            text: codeAgentClip(CodeAgentEventMapper.#renderToolText(event.partialResult), codeAgentLabelChars),
+          },
+        ];
+      case "tool_execution_end":
+        return [this.#mapToolEnd(event)];
+      case "queue_update":
+        return [{ type: "queue", steering: [...event.steering], followUp: [...event.followUp] }];
+      case "compaction_start":
+        return [{ type: "compaction", phase: "start", reason: event.reason }];
+      case "compaction_end":
+        return [
+          {
+            type: "compaction",
+            phase: "end",
+            reason: event.reason,
+            ...(event.errorMessage ? { error: event.errorMessage } : {}),
+            ...(event.aborted ? { aborted: true } : {}),
+          },
+        ];
+      case "auto_retry_start":
+        return [
+          {
+            type: "retry",
+            attempt: event.attempt,
+            maxAttempts: event.maxAttempts,
+            delayMs: event.delayMs,
+            message: event.errorMessage,
+          },
+        ];
+      default:
+        return [];
+    }
+  }
+
+  // The engine sends a blocked call no start event, only an `isError` end: synthesise the start, relabel the end.
+  markBlocked(toolCallId: string, toolName: string, args: unknown, reason: string): CodeAgentEventBody[] {
+    this.#blocked.set(toolCallId, reason);
+    if (this.#openTools.has(toolCallId)) return [];
+    const tool = this.#summary(toolCallId, toolName, args);
+    this.#openTools.set(toolCallId, tool);
+    return [{ type: "tool_start", turnId: this.#turnId, tool }];
+  }
+
+  /** A refusal the engine never closed would leave a row open forever, so the turn boundary sweeps them. */
+  flushBlocked(): CodeAgentEventBody[] {
+    const frames: CodeAgentEventBody[] = [];
+    for (const [toolCallId, reason] of this.#blocked) {
+      const tool = this.#openTools.get(toolCallId);
+      if (!tool) continue;
+      this.#openTools.delete(toolCallId);
+      frames.push({
+        type: "tool_end",
+        turnId: this.#turnId,
+        tool,
+        outcome: "blocked",
+        output: reason,
+        truncated: false,
+      });
+    }
+    this.#blocked.clear();
+    return frames;
+  }
+
+  #mapToolEnd(event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>): CodeAgentEventBody {
+    const tool = this.#openTools.get(event.toolCallId) ?? this.#summary(event.toolCallId, event.toolName, undefined);
+    this.#openTools.delete(event.toolCallId);
+    const reason = this.#blocked.get(event.toolCallId);
+    this.#blocked.delete(event.toolCallId);
+    const full = reason ?? CodeAgentEventMapper.#renderToolText(event.result);
+    return {
+      type: "tool_end",
+      turnId: this.#turnId,
+      tool,
+      outcome: reason ? "blocked" : event.isError ? "error" : "ok",
+      output: codeAgentClip(full, codeAgentOutputChars),
+      truncated: full.length > codeAgentOutputChars,
+    };
+  }
+
+  /** Consumed once, by the next `agent_end`, and wins over the engine's own stop reason. */
+  noteOutcome(reason: CodeAgentStopReason) {
+    this.#outcome = reason;
+  }
+
+  // The engine reports an interrupted stream as `stop`, so the core's own note wins and the engine's is a fallback.
+  #stopReason(event: Extract<AgentSessionEvent, { type: "agent_end" }>): CodeAgentStopReason {
+    const noted = this.#outcome;
+    this.#outcome = undefined;
+    if (noted) return noted;
+    if (event.willRetry) return "error";
+    const last = event.messages.at(-1) as { stopReason?: string } | undefined;
+    if (last?.stopReason === "aborted") return "aborted";
+    if (last?.stopReason === "error") return "error";
+    // `length` is the model hitting its output cap: a half-written answer must not be stored as `done`.
+    if (last?.stopReason === "length") return "truncated";
+    return "done";
+  }
+
+  #summary(toolCallId: string, name: string, args: unknown): CodeAgentToolSummary {
+    const path = stringArg(args, "path");
+    return {
+      toolCallId,
+      name,
+      op: toolOps[name] ?? "other",
+      ...(path ? { path } : {}),
+      title: codeAgentClip(`${name}${CodeAgentEventMapper.#renderArgs(args)}`, codeAgentLabelChars),
+    };
+  }
+
+  #mapDelta(event: Extract<AgentSessionEvent, { type: "message_update" }>): CodeAgentEventBody[] {
+    const inner = event.assistantMessageEvent;
+    if (inner.type === "text_delta") return [{ type: "text_delta", turnId: this.#turnId, text: inner.delta }];
+    if (inner.type === "thinking_delta") return [{ type: "thinking_delta", turnId: this.#turnId, text: inner.delta }];
+    return [];
+  }
+
+  #mapMessage(event: Extract<AgentSessionEvent, { type: "message_end" }>): CodeAgentEventBody[] {
+    const message = event.message as { role?: string; content?: unknown };
+    if (message.role !== "assistant" && message.role !== "user") return [];
+    const text = CodeAgentEventMapper.#renderContent(message.content);
+    if (!text) return [];
+    return [{ type: "message", turnId: this.#turnId, role: message.role, text }];
+  }
+
+  static #renderArgs(args: unknown) {
+    if (!args || typeof args !== "object") return "";
+    const entries = Object.entries(args as Record<string, unknown>).filter(([, value]) => value !== undefined);
+    if (!entries.length) return "";
+    const rendered = entries.map(([key, value]) => `${key}=${CodeAgentEventMapper.#renderArgValue(value)}`).join(" ");
+    return `(${codeAgentClip(rendered, 120)})`;
+  }
+
+  // By shape, not `String()`, which renders an `edit` call's replacement list as `[object Object]`s.
+  static #renderArgValue(value: unknown) {
+    if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? "" : "s"}`;
+    if (value && typeof value === "object") {
+      const keys = Object.keys(value as Record<string, unknown>).length;
+      return `{${keys} key${keys === 1 ? "" : "s"}}`;
+    }
+    return codeAgentClip(String(value), 60);
+  }
+
+  static #renderContent(content: unknown): string {
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+    return content
+      .filter(
+        (part): part is { type: string; text: string } => !!part && typeof part === "object" && part.type === "text",
+      )
+      .map((part) => part.text)
+      .join("");
+  }
+
+  static #renderToolText(value: unknown): string {
+    if (typeof value === "string") return value;
+    if (value && typeof value === "object" && "content" in value)
+      return CodeAgentEventMapper.#renderContent((value as { content: unknown }).content);
+    return value === undefined ? "" : JSON.stringify(value);
+  }
+}

package/codeAgent/agent/CodeAgentGate.ts

@@ -0,0 +1,93 @@
+import path from "node:path";
+import type { CodeAgentProfile } from "akanjs/common";
+import { stringArg } from "./stringArg";
+
+const writeTools = new Set(["write", "edit"]);
+const commandTools = new Set(["bash"]);
+
+export interface GateVerdict {
+  /** `undefined` means the call may run without asking. */
+  block?: string;
+  approval?: string;
+}
+
+// Gated here, not in the engine's file-ops port: a throw there reads to the model as a tool bug, and it retries.
+export class CodeAgentGate {
+  readonly #profile: CodeAgentProfile;
+  readonly #deny: Bun.Glob[];
+  readonly #allow: Bun.Glob[];
+  readonly #deniedFragments: string[];
+
+  constructor(profile: CodeAgentProfile) {
+    this.#profile = profile;
+    this.#deny = (profile.paths.deny ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#allow = (profile.paths.allow ?? []).map((pattern) => new Bun.Glob(pattern));
+    this.#deniedFragments = [...new Set((profile.paths.deny ?? []).map(CodeAgentGate.#fragmentOf).filter(Boolean))];
+  }
+
+  verdict(toolName: string, args: unknown): GateVerdict {
+    const target = stringArg(args, "path");
+    if (target) {
+      const denied = this.#deniedReason(target);
+      if (denied) return { block: denied };
+    }
+    const command = stringArg(args, "command");
+    if (command) {
+      const denied = this.#deniedCommandReason(command);
+      if (denied) return { block: denied };
+    }
+    if (!this.#needsApproval(toolName)) return {};
+    return { approval: CodeAgentGate.#summarize(toolName, args) };
+  }
+
+  // A speed bump, not a boundary: a shell reaches any path; the real boundary is the `pod` profile's container.
+  // It stops the obvious accident (`cat .env`) from persisting a live key into the transcript.
+  #deniedCommandReason(command: string) {
+    const hit = this.#deniedFragments.find((fragment) => command.includes(fragment));
+    if (!hit) return undefined;
+    return `The command names "${hit}", which the profile's deny list covers. Ask the user for the value instead of reading the file.`;
+  }
+
+  #deniedReason(target: string) {
+    const absolute = path.isAbsolute(target) ? target : path.resolve(this.#profile.paths.root, target);
+    const relative = path.relative(this.#profile.paths.root, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+      return `Path is outside the agent root (${this.#profile.paths.root}).`;
+    if (this.#deny.some((glob) => glob.match(absolute) || glob.match(relative)))
+      return "Path is on the profile's deny list (secrets and environment files are never readable).";
+    if (this.#allow.length && !this.#allow.some((glob) => glob.match(absolute) || glob.match(relative)))
+      return "Path is outside the profile's allow list.";
+    return undefined;
+  }
+
+  #needsApproval(toolName: string) {
+    switch (this.#profile.approval) {
+      case "never":
+        return false;
+      case "writes":
+        return writeTools.has(toolName);
+      case "commands":
+        return commandTools.has(toolName);
+      case "all":
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  // A glob cannot match a shell line, so a deny pattern is reduced to a literal; a mid-pattern wildcard is dropped.
+  static #fragmentOf(pattern: string) {
+    const trimmed = pattern
+      .replace(/^\*\*\//, "")
+      .replace(/\/\*\*$/, "/")
+      .replace(/^\*+/, "");
+    return trimmed.includes("*") ? "" : trimmed;
+  }
+
+  static #summarize(toolName: string, args: unknown) {
+    const record = (args ?? {}) as Record<string, unknown>;
+    if (toolName === "bash") return `run: ${String(record.command ?? "").slice(0, 200)}`;
+    const target = stringArg(args, "path");
+    return target ? `${toolName} ${target}` : toolName;
+  }
+}

package/codeAgent/agent/CodeAgentProxy.ts

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import type { CodeAgentProfile } from "akanjs/common";
+import { akanCodeDefaultModel } from "./akanCodeModel";
+
+interface PreparedRequest {
+  model: { provider: string; baseUrl?: string };
+  options: { apiKey?: string };
+}
+
+type PrepareRequest = (model: unknown, options?: Record<string, unknown>) => Promise<PreparedRequest>;
+
+export interface CodeAgentProxyOptions {
+  baseUrl: string;
+  providers: string[];
+  tokenFile?: string;
+  token?: string;
+}
+
+/** `baseUrl` may carry `{provider}` for a proxy that fronts several providers under one host. */
+export class CodeAgentProxy {
+  static readonly placeholderKey = "akan-code-proxy";
+
+  readonly baseUrl: string;
+  readonly providers: string[];
+  readonly #tokenFile?: string;
+  readonly #token?: string;
+
+  constructor({ baseUrl, providers, tokenFile, token }: CodeAgentProxyOptions) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.providers = providers;
+    this.#tokenFile = tokenFile;
+    this.#token = token;
+    if (!tokenFile && !token)
+      throw new Error("AKAN_CODE_PROXY_URL needs AKAN_CODE_PROXY_TOKEN_FILE or AKAN_CODE_PROXY_TOKEN");
+  }
+
+  static fromEnv(profile?: CodeAgentProfile): CodeAgentProxy | null {
+    const baseUrl = process.env.AKAN_CODE_PROXY_URL?.trim() || profile?.network.proxyBaseUrl;
+    if (!baseUrl) return null;
+    const providers = (process.env.AKAN_CODE_PROXY_PROVIDERS ?? akanCodeDefaultModel.provider)
+      .split(",")
+      .map((provider) => provider.trim())
+      .filter(Boolean);
+    return new CodeAgentProxy({
+      baseUrl,
+      providers,
+      tokenFile: process.env.AKAN_CODE_PROXY_TOKEN_FILE?.trim() || undefined,
+      token: process.env.AKAN_CODE_PROXY_TOKEN?.trim() || undefined,
+    });
+  }
+
+  baseUrlFor(provider: string) {
+    return this.baseUrl.replaceAll("{provider}", provider);
+  }
+
+  //* Read per request, not cached: the host rotates the token while a session is still running.
+  async token() {
+    if (!this.#tokenFile) return this.#token ?? "";
+    const token = (await readFile(this.#tokenFile, "utf8")).trim();
+    if (!token) throw new Error(`${this.#tokenFile} is empty`);
+    return token;
+  }
+
+  // `prepareRequest` is the one path every request takes. It is engine-private, so an upgrade that drops it must
+  // fail here at boot rather than send a request with no key.
+  async apply(runtime: ModelRuntime) {
+    const target = runtime as unknown as { prepareRequest?: PrepareRequest };
+    const original = target.prepareRequest?.bind(runtime);
+    if (!original) throw new Error("The model runtime no longer exposes prepareRequest; update CodeAgentProxy");
+    for (const provider of this.providers) await runtime.setRuntimeApiKey(provider, CodeAgentProxy.placeholderKey);
+    target.prepareRequest = async (model, options = {}) => {
+      const apiKey = await this.token();
+      const prepared = await original(model, { ...options, apiKey });
+      return {
+        ...prepared,
+        model: { ...prepared.model, baseUrl: this.baseUrlFor(prepared.model.provider) },
+        options: { ...prepared.options, apiKey },
+      };
+    };
+  }
+}

package/codeAgent/agent/CodeAgentRpcHost.ts

@@ -0,0 +1,103 @@
+import type { CodeAgentCommand, CodeAgentEvent, CodeAgentReply, CodeAgentRequest } from "akanjs/common";
+import type { CodeAgent } from "./CodeAgent";
+
+// stdout carries only frames because `consoleToStderr` was imported before the engine (Bun's console bypasses it).
+export class CodeAgentRpcHost {
+  readonly #agent: CodeAgent;
+  #write: ((line: string) => void) | null;
+  #buffer = "";
+  #started = false;
+  #resolveShutdown: () => void = () => {};
+  readonly shutdown = new Promise<void>((resolve) => {
+    this.#resolveShutdown = resolve;
+  });
+
+  constructor(agent: CodeAgent, write: ((line: string) => void) | null = (line) => process.stdout.write(line)) {
+    this.#agent = agent;
+    this.#write = write;
+  }
+
+  async serve(input: AsyncIterable<Uint8Array> = process.stdin) {
+    this.start();
+    const decoder = new TextDecoder();
+    for await (const chunk of input) await this.feed(decoder.decode(chunk, { stream: true }));
+    await this.#agent.abort().catch(() => {});
+  }
+
+  start() {
+    if (this.#started) return;
+    this.#started = true;
+    this.#agent.on((event) => this.#emit(event));
+    this.#agent.announce();
+  }
+
+  //* Frames with no client attached are dropped; the next client catches up with `get_state { sinceSeq }`.
+  attach(write: ((line: string) => void) | null) {
+    this.#write = write;
+    this.#buffer = "";
+  }
+
+  async feed(text: string) {
+    this.#buffer += text;
+    let index = this.#buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.#buffer.slice(0, index).trim();
+      this.#buffer = this.#buffer.slice(index + 1);
+      if (line) await this.#handle(line);
+      index = this.#buffer.indexOf("\n");
+    }
+  }
+
+  async #handle(line: string) {
+    let request: CodeAgentRequest;
+    try {
+      request = JSON.parse(line) as CodeAgentRequest;
+    } catch {
+      return this.#emit({ type: "error", message: "malformed command frame", fatal: false, seq: -1 });
+    }
+    try {
+      this.#reply({ type: "reply", id: request.id, ok: true, data: await this.#run(request.command) });
+    } catch (error) {
+      this.#reply({ type: "reply", id: request.id, ok: false, error: String(error) });
+    }
+    //* After the reply, so a socket transport that closes on shutdown has already written the acknowledgement.
+    if (request.command?.type === "shutdown") this.#resolveShutdown();
+  }
+
+  // `prompt` replies on acceptance, not completion, so the client can still send `abort` while the turn runs.
+  async #run(command: CodeAgentCommand): Promise<unknown> {
+    switch (command.type) {
+      case "prompt":
+        void this.#agent.prompt(command.message, command.images);
+        return { accepted: true };
+      case "answer":
+        return { handled: await this.#agent.answer(command.questionId, command.answer) };
+      case "approve":
+        return { handled: await this.#agent.approve(command.approvalId, command.approved) };
+      case "abort":
+        await this.#agent.abort();
+        return { aborted: true };
+      case "compact":
+        await this.#agent.compact(command.instructions);
+        return { compacted: true };
+      case "set_model":
+        await this.#agent.setModel({ provider: command.provider, id: command.modelId });
+        return await this.#agent.state();
+      case "get_state":
+        return await this.#agent.state(command.sinceSeq === undefined ? {} : { sinceSeq: command.sinceSeq });
+      case "shutdown":
+        this.#agent.dispose();
+        return { shutdown: true };
+      default:
+        throw new Error(`Unsupported command: ${command.type}`);
+    }
+  }
+
+  #emit(event: CodeAgentEvent) {
+    this.#write?.(`${JSON.stringify({ type: "event", event })}\n`);
+  }
+
+  #reply(reply: CodeAgentReply) {
+    this.#write?.(`${JSON.stringify(reply)}\n`);
+  }
+}

package/codeAgent/agent/CodeAgentRpcListener.ts

@@ -0,0 +1,109 @@
+import { existsSync, rmSync } from "node:fs";
+import type { Socket, SocketListener } from "bun";
+import type { CodeAgentRpcHost } from "./CodeAgentRpcHost";
+
+export type CodeAgentRpcAddress = { unix: string } | { hostname: string; port: number };
+
+interface ClientState {
+  pending: Buffer | null;
+  decoder: TextDecoder;
+}
+
+// One client at a time: a reconnecting control plane replaces a socket that has not timed out yet.
+// TCP binds 127.0.0.1 unless a host is named, because the wire has no authentication of its own.
+export class CodeAgentRpcListener {
+  readonly #host: CodeAgentRpcHost;
+  readonly #address: CodeAgentRpcAddress;
+  #listener: SocketListener<ClientState> | null = null;
+  #client: Socket<ClientState> | null = null;
+
+  constructor(host: CodeAgentRpcHost, address: CodeAgentRpcAddress) {
+    this.#host = host;
+    this.#address = address;
+  }
+
+  static parse(spec: string): CodeAgentRpcAddress {
+    if (spec.startsWith("unix:")) return { unix: spec.slice("unix:".length) };
+    const rest = spec.startsWith("tcp:") ? spec.slice("tcp:".length) : spec;
+    const separator = rest.lastIndexOf(":");
+    const hostname = separator >= 0 ? rest.slice(0, separator) : "127.0.0.1";
+    const port = Number(separator >= 0 ? rest.slice(separator + 1) : rest);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535)
+      throw new Error(`--rpc-listen takes unix:<path> or tcp:[host:]<port>, not "${spec}"`);
+    return { hostname: hostname || "127.0.0.1", port };
+  }
+
+  get port() {
+    return this.#listener && "port" in this.#listener ? this.#listener.port : null;
+  }
+
+  listen() {
+    if ("unix" in this.#address && existsSync(this.#address.unix)) rmSync(this.#address.unix);
+    const socket = {
+      open: (client: Socket<ClientState>) => this.#open(client),
+      data: (client: Socket<ClientState>, data: Buffer) => this.#data(client, data),
+      drain: (client: Socket<ClientState>) => this.#drain(client),
+      close: (client: Socket<ClientState>) => this.#close(client),
+      error: (client: Socket<ClientState>) => this.#close(client),
+    };
+    this.#listener =
+      "unix" in this.#address
+        ? Bun.listen<ClientState>({ unix: this.#address.unix, socket })
+        : Bun.listen<ClientState>({ hostname: this.#address.hostname, port: this.#address.port, socket });
+    this.#host.start();
+    return this;
+  }
+
+  async serve() {
+    if (!this.#listener) this.listen();
+    await this.#host.shutdown;
+    this.stop();
+  }
+
+  stop() {
+    this.#client?.end();
+    this.#client = null;
+    this.#host.attach(null);
+    this.#listener?.stop(true);
+    this.#listener = null;
+    if ("unix" in this.#address && existsSync(this.#address.unix)) rmSync(this.#address.unix);
+  }
+
+  #open(client: Socket<ClientState>) {
+    client.data = { pending: null, decoder: new TextDecoder() };
+    const previous = this.#client;
+    this.#client = client;
+    previous?.end();
+    this.#host.attach((line) => this.#write(client, line));
+  }
+
+  #data(client: Socket<ClientState>, data: Buffer) {
+    if (client !== this.#client) return;
+    void this.#host.feed(client.data.decoder.decode(data, { stream: true }));
+  }
+
+  //* A socket write may take only part of a frame; the rest waits for `drain`, and frames behind it queue in order.
+  #write(client: Socket<ClientState>, line: string) {
+    if (client !== this.#client) return;
+    const bytes = Buffer.from(line);
+    if (client.data.pending) {
+      client.data.pending = Buffer.concat([client.data.pending, bytes]);
+      return;
+    }
+    const written = client.write(bytes);
+    if (written < bytes.length) client.data.pending = bytes.subarray(Math.max(0, written));
+  }
+
+  #drain(client: Socket<ClientState>) {
+    const pending = client.data.pending;
+    if (!pending) return;
+    const written = client.write(pending);
+    client.data.pending = written < pending.length ? pending.subarray(Math.max(0, written)) : null;
+  }
+
+  #close(client: Socket<ClientState>) {
+    if (client !== this.#client) return;
+    this.#client = null;
+    this.#host.attach(null);
+  }
+}