@remodex/rmx 1.0.2

package/src/lib/service-secrets.ts

@@ -0,0 +1,178 @@
+import { join, resolve } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, truncateSync, unlinkSync } from "node:fs";
+import { atomicWriteFile, getConfigDir } from "../config";
+import type { OcxConfig } from "../types";
+import { providerEnvironmentReferences } from "./provider-environment";
+
+export function serviceApiTokenFilePath(): string {
+  return join(getConfigDir(), "service-api-token");
+}
+
+/** Pointer carried by every durable service wrapper; the file itself is owner-only. */
+export const SERVICE_PROVIDER_ENV_FILE_ENV = "OCX_PROVIDER_ENV_FILE";
+
+/**
+ * The durable provider snapshot is safe to hydrate for both supervised service
+ * children and the installed desktop shell's short-lived CLI actions. Keeping
+ * this predicate here makes the trust boundary explicit: ordinary interactive
+ * commands do not implicitly load a persisted secret file.
+ */
+export function shouldLoadServiceProviderEnvironment(
+  env: Record<string, string | undefined> = process.env,
+): boolean {
+  return env.OCX_SERVICE === "1" || env.OCX_DESKTOP === "1";
+}
+
+const SERVICE_PROVIDER_ENV_FILE = "service-provider-env.json";
+const SERVICE_PROVIDER_ENV_VERSION = 1;
+const MAX_SERVICE_PROVIDER_ENV_BYTES = 256 * 1024;
+const MAX_SERVICE_PROVIDER_ENV_VALUES = 128;
+const MAX_SERVICE_PROVIDER_ENV_VALUE_BYTES = 64 * 1024;
+
+type ServiceProviderEnvFile = {
+  version: 1;
+  variables: Record<string, string>;
+};
+
+function validEnvironmentName(value: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+  return value?.trim() ? value : undefined;
+}
+
+/**
+ * Environment names which must survive an interactive shell → durable-service handoff.
+ *
+ * The config deliberately keeps these as `${NAME}` references rather than writing provider
+ * credentials to config.json. A launchd/systemd/Task Scheduler service does not inherit the
+ * user's shell, so the service installer snapshots only the referenced values into an owner-only
+ * file and gives the child a pointer to it. OAuth/forward/local providers do not use apiKey.
+ */
+export function serviceProviderEnvironmentReferences(
+  config: Pick<OcxConfig, "proxy" | "providers">,
+): string[] {
+  return providerEnvironmentReferences(config);
+}
+
+export function serviceProviderEnvFilePath(): string {
+  return join(getConfigDir(), SERVICE_PROVIDER_ENV_FILE);
+}
+
+function safeReadServiceProviderEnvFile(path: string): Record<string, string> {
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_SERVICE_PROVIDER_ENV_BYTES) return {};
+    if (process.platform !== "win32" && (stat.mode & 0o077) !== 0) return {};
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as Partial<ServiceProviderEnvFile>;
+    if (parsed.version !== SERVICE_PROVIDER_ENV_VERSION || !parsed.variables || typeof parsed.variables !== "object" || Array.isArray(parsed.variables)) return {};
+    const values: Record<string, string> = Object.create(null) as Record<string, string>;
+    for (const [name, value] of Object.entries(parsed.variables)) {
+      if (Object.keys(values).length >= MAX_SERVICE_PROVIDER_ENV_VALUES) break;
+      if (!validEnvironmentName(name) || typeof value !== "string" || value.includes("\0")) continue;
+      if (Buffer.byteLength(value, "utf8") > MAX_SERVICE_PROVIDER_ENV_VALUE_BYTES) continue;
+      values[name] = value;
+    }
+    return values;
+  } catch {
+    return {};
+  }
+}
+
+/** Values that a service can use now, without overriding explicitly supplied manager variables. */
+export function unresolvedServiceProviderEnvironment(
+  config: Pick<OcxConfig, "proxy" | "providers">,
+  env: Record<string, string | undefined> = process.env,
+): string[] {
+  const saved = safeReadServiceProviderEnvFile(serviceProviderEnvFilePath());
+  return serviceProviderEnvironmentReferences(config).filter(name => !nonEmpty(env[name]) && !nonEmpty(saved[name]));
+}
+
+export function removeServiceProviderEnvFile(): void {
+  const path = serviceProviderEnvFilePath();
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink()) return;
+    try { truncateSync(path, 0); } catch { /* unlink may still succeed */ }
+    unlinkSync(path);
+  } catch {
+    /* no owner-only snapshot to remove */
+  }
+}
+
+/**
+ * Persist the effective values for referenced provider/config env vars. The supplied process
+ * environment wins; a previous owner-only snapshot is retained only when a repair runs from a
+ * shell that no longer exports the value. Missing references are reported, never serialized.
+ */
+export function writeServiceProviderEnvironment(
+  config: Pick<OcxConfig, "proxy" | "providers">,
+  env: Record<string, string | undefined> = process.env,
+): { missing: string[]; written: number } {
+  const names = serviceProviderEnvironmentReferences(config);
+  if (names.length === 0) {
+    removeServiceProviderEnvFile();
+    return { missing: [], written: 0 };
+  }
+  const previous = safeReadServiceProviderEnvFile(serviceProviderEnvFilePath());
+  const variables: Record<string, string> = {};
+  const missing: string[] = [];
+  for (const name of names) {
+    const value = nonEmpty(env[name]) ?? nonEmpty(previous[name]);
+    if (!value) {
+      missing.push(name);
+      continue;
+    }
+    variables[name] = value;
+  }
+  if (missing.length > 0) return { missing, written: 0 };
+
+  const dir = getConfigDir();
+  const path = serviceProviderEnvFilePath();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
+  atomicWriteFile(
+    path,
+    `${JSON.stringify({ version: SERVICE_PROVIDER_ENV_VERSION, variables } satisfies ServiceProviderEnvFile)}\n`,
+  );
+  return { missing: [], written: Object.keys(variables).length };
+}
+
+/**
+ * Hydrate an Remodex service process from its exact owner-only snapshot. A pointer outside the
+ * active OPENCODEX_HOME is ignored so project-controlled dotenv files cannot make `rmx` read an
+ * arbitrary path. Existing manager-provided variables always win over the snapshot.
+ */
+export function loadServiceProviderEnvironmentFromFile(
+  env: Record<string, string | undefined> = process.env,
+): number {
+  const requested = env[SERVICE_PROVIDER_ENV_FILE_ENV]?.trim();
+  if (!requested) return 0;
+  const expected = serviceProviderEnvFilePath();
+  if (resolve(requested) !== resolve(expected)) return 0;
+  let loaded = 0;
+  for (const [name, value] of Object.entries(safeReadServiceProviderEnvFile(expected))) {
+    if (nonEmpty(env[name])) continue;
+    env[name] = value;
+    loaded += 1;
+  }
+  return loaded;
+}
+
+/**
+ * App-side service token loading (WinSW native mode has no batch wrapper to read the
+ * token file into the environment). Pure: returns the token or null — the CALLER
+ * assigns it to process.env.OPENCODEX_API_AUTH_TOKEN. Loads only when the env token
+ * is empty and OCX_API_TOKEN_FILE names a readable file.
+ */
+export function loadServiceTokenFromFile(env: Record<string, string | undefined>): string | null {
+  if (env.OPENCODEX_API_AUTH_TOKEN?.trim()) return null;
+  const file = env.OCX_API_TOKEN_FILE?.trim();
+  if (!file) return null;
+  try {
+    const token = readFileSync(file, "utf8").trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/shadow-call.ts

@@ -0,0 +1,54 @@
+/**
+ * Shadow-call intercept source models.
+ *
+ * Codex 0.145.0+ uses `gpt-5.6-luna` for helper calls. Older clients through
+ * 0.144.x used `gpt-5.4-mini`; operators supporting them can restore that
+ * prefix with the `sourceModels` override. Every surface that names the
+ * intercepted model (management API, GUI badges/tooltips, CLI) reads it from
+ * here instead of hard-coding a slug that goes stale on the next client bump.
+ */
+export const DEFAULT_SHADOW_SOURCE_MODELS = ["gpt-5.6-luna"] as const;
+
+/** Normalize a persisted `sourceModels` override; falls back to the defaults. */
+export function shadowSourceModels(configured?: unknown): string[] {
+  const configuredStrings = Array.isArray(configured)
+    ? configured
+      .filter((v): v is string => typeof v === "string" && v.trim() !== "")
+      .map(v => v.trim())
+    : [];
+  return configuredStrings.length > 0 ? configuredStrings : [...DEFAULT_SHADOW_SOURCE_MODELS];
+}
+
+/**
+ * True when `modelId` is one of Codex's helper/shadow source models.
+ * Routed ids (`provider/model`) are hard-excluded: a shadow call is always a
+ * bare native slug, and an explicit routed selection must never be hijacked.
+ */
+export function isShadowSourceModel(modelId: string, configured?: unknown): boolean {
+  if (modelId.includes("/")) return false;
+  return shadowSourceModels(configured).some(prefix => modelId.startsWith(prefix));
+}
+
+/**
+ * Decide whether a matching source model should use the opt-in intercept.
+ *
+ * Codex 0.145.0+ identifies normal user turns and maintenance requests in
+ * x-codex-turn-metadata. Only an explicit normal turn bypasses interception;
+ * missing or unrecognized metadata retains the legacy opt-in prefix behavior.
+ */
+export function shouldInterceptShadowCall(
+  modelId: string,
+  configured: unknown,
+  headers: Headers,
+): boolean {
+  if (!isShadowSourceModel(modelId, configured)) return false;
+  const rawMetadata = headers.get("x-codex-turn-metadata");
+  if (rawMetadata === null) return true;
+
+  try {
+    const parsed = JSON.parse(rawMetadata) as { request_kind?: unknown };
+    return parsed?.request_kind !== "turn";
+  } catch {
+    return true;
+  }
+}

package/src/lib/sidecar-tracker.ts

@@ -0,0 +1,52 @@
+/**
+ * Lightweight in-flight breadcrumb for sidecar work (web-search / vision), read by crash-guard.
+ *
+ * The proxy's unhandled rejections arrive with a native-only stack, so the throw site is invisible.
+ * To confirm or rule out the strong correlation with sidecar activity (the gpt-mini web-search /
+ * vision passes that run an EXTRA upstream fetch alongside the main turn), each sidecar call brackets
+ * itself with enter()/exit(). crash-guard then records whether any sidecar was in flight when a
+ * rejection fired — turning a guess into evidence without a debugger.
+ */
+let inFlight = 0;
+let lastLabel = "";
+let lastEnterAt = 0;
+
+export function sidecarEnter(label: string): () => void {
+  inFlight++;
+  lastLabel = truncateRetainedUtf8(label, MAX_DIAGNOSTIC_VALUE_BYTES);
+  lastEnterAt = Date.now();
+  let exited = false;
+  return () => {
+    if (exited) return;
+    exited = true;
+    if (inFlight > 0) inFlight--;
+  };
+}
+
+export function sidecarBreadcrumb(): { inFlight: number; lastLabel: string; sinceMs: number } {
+  return {
+    inFlight,
+    lastLabel,
+    sinceMs: lastEnterAt ? Date.now() - lastEnterAt : 0,
+  };
+}
+
+/**
+ * Generic last-activity breadcrumb (any code path, not just sidecars). The proxy's native-only
+ * rejections carry no source location, so we record the most recent meaningful activity —
+ * request path + a short note — to correlate the next fault with what the daemon was doing.
+ */
+let lastActivity = "";
+let lastActivityAt = 0;
+
+export function markActivity(note: string): void {
+  lastActivity = truncateRetainedUtf8(note, MAX_DIAGNOSTIC_VALUE_BYTES);
+  lastActivityAt = Date.now();
+}
+
+export function activityBreadcrumb(): { note: string; sinceMs: number } {
+  return { note: lastActivity, sinceMs: lastActivityAt ? Date.now() - lastActivityAt : 0 };
+}
+import { truncateRetainedUtf8 } from "./admission";
+
+const MAX_DIAGNOSTIC_VALUE_BYTES = 8 * 1024;

package/src/lib/sse-decoder.ts

@@ -0,0 +1,364 @@
+import {
+  TRANSLATOR_MAX_SSE_EVENT_BYTES,
+  TranslatorBudgetExceededError,
+  type TranslatorBudget,
+} from "./translator-budget";
+
+export interface ServerSentEvent {
+  event?: string;
+  data: string;
+}
+
+export type SseRecord =
+  | { kind: "event"; event?: string; data: string }
+  | { kind: "comment"; comment: string };
+
+/**
+ * Extract one SSE field value from a single line, or null when the line is a different field.
+ *
+ * The space after the colon is OPTIONAL in text/event-stream: `data:{"a":1}` is as valid as
+ * `data: {"a":1}`. Parsers that hardcoded `startsWith("data: ")` silently dropped every frame
+ * from a producer that omits it, which surfaced as a completed turn with no content (#1170).
+ *
+ * Strips at most ONE leading space — the same rule `decodeServerSentEvents` applies below — so a
+ * payload that legitimately begins with whitespace keeps the rest of it. Does not trim the value:
+ * callers own that choice, and some of them intentionally keep trailing bytes.
+ */
+export function sseFieldValue(line: string, field: string): string | null {
+  if (!line.startsWith(field)) return null;
+  const rest = line.slice(field.length);
+  // A colonless field line is the field with an empty value per the SSE rules, and
+  // `decodeServerSentEvents` below treats it that way (`colon < 0` -> valueStart = line.length).
+  // These helpers must not disagree with the decoder they mirror.
+  if (rest.length === 0) return "";
+  if (!rest.startsWith(":")) return null;
+  return rest.startsWith(": ") ? rest.slice(2) : rest.slice(1);
+}
+
+/**
+ * Offset-only variant of {@link sseFieldValue} for parsers that index into a larger buffer.
+ *
+ * Returns the index where the field's value begins within `text`, or -1 when the line at
+ * `[lineStart, lineEnd)` is a different field. Slicing nothing matters for the live Claude relay,
+ * whose translator-budget accounting reserves bytes by offset — materializing the line first would
+ * allocate the very string the budget exists to bound.
+ */
+export function sseFieldOffset(text: string, lineStart: number, lineEnd: number, field: string): number {
+  if (!text.startsWith(field, lineStart)) return -1;
+  let valueStart = lineStart + field.length;
+  // Colonless field line: empty value, positioned at end-of-line (matches the decoder).
+  if (valueStart >= lineEnd) return lineEnd;
+  if (text[valueStart] !== ":") return -1;
+  valueStart += 1;
+  if (valueStart < lineEnd && text[valueStart] === " ") valueStart += 1;
+  return valueStart;
+}
+
+/**
+ * Decode text/event-stream records across arbitrary fetch chunk boundaries.
+ *
+ * The final record is dispatched at EOF even when the upstream omits the trailing blank line or
+ * final newline. That matters for compatible APIs that place a terminal event in the last bytes of
+ * the body: dropping that record turns a successful response into an adapter_eof failure.
+ */
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments: true; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<SseRecord>;
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: false; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent>;
+export async function* decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments?: boolean; signal?: AbortSignal; translatorBudget: TranslatorBudget },
+): AsyncGenerator<ServerSentEvent | SseRecord> {
+  const translatorBudget = options.translatorBudget;
+  const reader = source.getReader();
+  const decoder = new TextDecoder();
+  let lineBuffer = "";
+  let lineRawBytes = 0;
+  let lineRetainedBytes = 0;
+  let event: string | undefined;
+  let eventBytes = 0;
+  let dataLines: string[] = [];
+  let dataLinesBytes = 0;
+  const scope = { kind: "live_transient" as const };
+
+  const utf8SliceBytes = (value: string, start: number, end: number): number => {
+    let bytes = 0;
+    for (let index = start; index < end; index++) {
+      const codePoint = value.codePointAt(index)!;
+      if (codePoint <= 0x7f) bytes += 1;
+      else if (codePoint <= 0x7ff) bytes += 2;
+      else if (codePoint <= 0xffff) bytes += 3;
+      else {
+        bytes += 4;
+        index += 1;
+      }
+    }
+    return bytes;
+  };
+
+  const linePrefixAfter = (sourceValue: string, start: number, end: number): string => {
+    if (lineBuffer.length >= 6) return lineBuffer.slice(0, 6);
+    return (lineBuffer + sourceValue.slice(start, Math.min(end, start + 6 - lineBuffer.length))).slice(0, 6);
+  };
+
+  const accountedLineBytes = (rawBytes: number, prefix: string): number => {
+    if (prefix.length < 5 && "data:".startsWith(prefix)) return 0;
+    if (!prefix.startsWith("data:")) return rawBytes;
+    return Math.max(0, rawBytes - (prefix[5] === " " ? 6 : 5));
+  };
+
+  const appendLine = (sourceValue: string, start: number, end: number): void => {
+    if (start >= end) return;
+    const nextRawBytes = lineRawBytes + utf8SliceBytes(sourceValue, start, end);
+    const prefix = linePrefixAfter(sourceValue, start, end);
+    const nextRetainedBytes = accountedLineBytes(nextRawBytes, prefix);
+    if (prefix.startsWith("data:")) {
+      const logicalEventBytes = dataLinesBytes + dataLines.length + nextRetainedBytes;
+      if (logicalEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+        throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+      }
+    }
+    const reservation = translatorBudget.reserveTransient(nextRawBytes, scope);
+    try {
+      const fragment = sourceValue.slice(start, end);
+      lineBuffer += fragment;
+      reservation.commitRetained();
+      translatorBudget.releaseRetained(lineRetainedBytes, scope);
+      lineRawBytes = nextRawBytes;
+      lineRetainedBytes = nextRawBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  // Prompt cancellation channel: an abort cancels the underlying reader directly, which
+  // settles any in-flight read() so a consumer's iterator.return() cannot hang behind an
+  // idle upstream (a plain generator return waits for the pending await first).
+  const signal = options?.signal;
+  const onAbort = () => { reader.cancel(signal?.reason).catch(() => { /* already closed */ }); };
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+
+  const includeComments = options?.includeComments === true;
+
+  const dispatch = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    if (dataLines.length === 0) {
+      translatorBudget.releaseRetained(eventBytes, scope);
+      event = undefined;
+      eventBytes = 0;
+      return undefined;
+    }
+    const payloadBytes = dataLinesBytes + Math.max(0, dataLines.length - 1);
+    if (payloadBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+      throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+    }
+    let data: string;
+    if (dataLines.length === 1) {
+      data = dataLines[0]!;
+    } else {
+      const reservation = translatorBudget.reserveTransient(payloadBytes, scope);
+      try {
+        data = dataLines.join("\n");
+        reservation.commitRetained();
+        translatorBudget.releaseRetained(dataLinesBytes, scope);
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+    }
+    const record = { ...(event ? { event } : {}), data };
+    const retainedRecordBytes = payloadBytes + eventBytes;
+    event = undefined;
+    eventBytes = 0;
+    dataLines = [];
+    dataLinesBytes = 0;
+    return {
+      record: includeComments ? { kind: "event", ...record } : record,
+      bytes: retainedRecordBytes,
+    };
+  };
+
+  const acceptLine = (): { record: ServerSentEvent | SseRecord; bytes: number } | undefined => {
+    let line = lineBuffer;
+    let retainedLineBytes = lineRetainedBytes;
+    let lineOwned = true;
+    const releaseLine = (): void => {
+      if (!lineOwned) return;
+      lineOwned = false;
+      translatorBudget.releaseRetained(retainedLineBytes, scope);
+    };
+    lineBuffer = "";
+    lineRawBytes = 0;
+    lineRetainedBytes = 0;
+    try {
+      if (line.endsWith("\r")) {
+        const nextLineBytes = retainedLineBytes - 1;
+        const reservation = translatorBudget.reserveTransient(nextLineBytes, scope);
+        try {
+          const nextLine = line.slice(0, -1);
+          reservation.commitRetained();
+          translatorBudget.releaseRetained(retainedLineBytes, scope);
+          line = nextLine;
+          retainedLineBytes = nextLineBytes;
+        } catch (error) {
+          reservation.release();
+          throw error;
+        }
+      }
+      if (line === "") {
+        releaseLine();
+        return dispatch();
+      }
+      if (line.startsWith(":")) {
+        if (!includeComments) {
+          releaseLine();
+          return undefined;
+        }
+        const commentStart = line[1] === " " ? 2 : 1;
+        const commentBytes = utf8SliceBytes(line, commentStart, line.length);
+        translatorBudget.chargeRetained(commentBytes, scope);
+        try {
+          const comment = line.slice(commentStart);
+          releaseLine();
+          return { record: { kind: "comment", comment }, bytes: commentBytes };
+        } catch (error) {
+          translatorBudget.releaseRetained(commentBytes, scope);
+          throw error;
+        }
+      }
+
+      const colon = line.indexOf(":");
+      const fieldEnd = colon < 0 ? line.length : colon;
+      const fieldBytes = utf8SliceBytes(line, 0, fieldEnd);
+      const fieldReservation = translatorBudget.reserveTransient(fieldBytes, scope);
+      let field = "";
+      try {
+        field = line.slice(0, fieldEnd);
+        fieldReservation.commitRetained();
+      } catch (error) {
+        fieldReservation.release();
+        throw error;
+      }
+      try {
+        let valueStart = colon < 0 ? line.length : colon + 1;
+        if (line[valueStart] === " ") valueStart += 1;
+        const valueBytes = utf8SliceBytes(line, valueStart, line.length);
+
+        if (field === "event") {
+          const reservation = translatorBudget.reserveTransient(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            reservation.commitRetained();
+            translatorBudget.releaseRetained(eventBytes, scope);
+            event = value;
+            eventBytes = valueBytes;
+            releaseLine();
+          } catch (error) {
+            reservation.release();
+            throw error;
+          }
+        }
+        else if (field === "data") {
+          const nextEventBytes = dataLinesBytes + valueBytes + dataLines.length;
+          if (nextEventBytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) {
+            throw new TranslatorBudgetExceededError("live_transient", TRANSLATOR_MAX_SSE_EVENT_BYTES);
+          }
+          // The extracted value is a distinct retained allocation while the source line is still
+          // live. Admit that insertion before slicing/pushing, then release the source owner.
+          translatorBudget.chargeRetained(valueBytes, scope);
+          try {
+            const value = line.slice(valueStart);
+            dataLines.push(value);
+            dataLinesBytes += valueBytes;
+            releaseLine();
+          } catch (error) {
+            translatorBudget.releaseRetained(valueBytes, scope);
+            throw error;
+          }
+        } else {
+          releaseLine();
+        }
+      } finally {
+        translatorBudget.releaseRetained(fieldBytes, scope);
+      }
+      return undefined;
+    } catch (error) {
+      releaseLine();
+      throw error;
+    }
+  };
+
+  const consumeDecoded = async function* (
+    decoded: string,
+  ): AsyncGenerator<ServerSentEvent | SseRecord> {
+    let offset = 0;
+    while (offset < decoded.length) {
+      const newline = decoded.indexOf("\n", offset);
+      if (newline < 0) {
+        appendLine(decoded, offset, decoded.length);
+        return;
+      }
+      appendLine(decoded, offset, newline);
+      const accepted = acceptLine();
+      if (accepted) {
+        try {
+          yield accepted.record;
+        } finally {
+          translatorBudget.releaseRetained(accepted.bytes, scope);
+        }
+      }
+      offset = newline + 1;
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (value) {
+        const sourceBytes = value.byteLength;
+        const sourceReservation = translatorBudget.reserveTransient(sourceBytes, scope);
+        let sourceCommitted = false;
+        try {
+          const decoded = decoder.decode(value, { stream: !done });
+          sourceReservation.commitRetained();
+          sourceCommitted = true;
+          yield* consumeDecoded(decoded);
+        } finally {
+          if (sourceCommitted) translatorBudget.releaseRetained(sourceBytes, scope);
+          else sourceReservation.release();
+        }
+      }
+      if (!done) continue;
+      const finalDecoded = decoder.decode();
+      yield* consumeDecoded(finalDecoded);
+      if (lineBuffer.length > 0) {
+        const accepted = acceptLine();
+        if (accepted) {
+          try {
+            yield accepted.record;
+          } finally {
+            translatorBudget.releaseRetained(accepted.bytes, scope);
+          }
+        }
+      }
+      const finalRecord = dispatch();
+      if (finalRecord) {
+        try {
+          yield finalRecord.record;
+        } finally {
+          translatorBudget.releaseRetained(finalRecord.bytes, scope);
+        }
+      }
+      break;
+    }
+  } finally {
+    translatorBudget.releaseRetained(lineRetainedBytes + dataLinesBytes + eventBytes, scope);
+    signal?.removeEventListener("abort", onAbort);
+    try { await reader.cancel(); } catch { /* already closed/errored */ }
+    try { reader.releaseLock(); } catch { /* already released */ }
+  }
+}