// Shared safety wrapper around a WHATWG ReadableStream controller.
//
// The consumer (RSC encoder, fetch response body, browser <audio>/<video>)
// can close the stream at any time. Once that happens, calling enqueue/
// close/error on the controller throws ERR_INVALID_STATE — and because the
// throw surfaces inside the encoder's own pipeline, not at our call site,
// it leaks as an uncaughtException. Tracking a `closed` flag and gating all
// controller ops on it ensures we stop producing the moment the downstream
// goes away.
//
// `markClosed()` is for the cancel() / finally() paths where we already know
// the stream is gone and don't want to attempt close().

export type SafeStreamController<T> = {
  setController: (c: ReadableStreamDefaultController<T>) => void;
  safeEnqueue: (chunk: T) => void;
  safeClose: () => void;
  safeError: (err: unknown) => void;
  markClosed: () => void;
  isClosed: () => boolean;
};

export function makeSafeController<T>(): SafeStreamController<T> {
  let controller: ReadableStreamDefaultController<T> | null = null;
  let closed = false;
  const setController = (c: ReadableStreamDefaultController<T>) => {
    controller = c;
  };
  const safeEnqueue = (chunk: T) => {
    if (closed) return;
    try {
      controller?.enqueue(chunk);
    } catch (err) {
      if (
        (err as NodeJS.ErrnoException | undefined)?.code === "ERR_INVALID_STATE"
      ) {
        closed = true;
      }
    }
  };
  const safeClose = () => {
    if (closed) return;
    closed = true;
    try {
      controller?.close();
    } catch {}
  };
  const safeError = (err: unknown) => {
    if (closed) return;
    closed = true;
    try {
      controller?.error(err);
    } catch {}
  };
  const markClosed = () => {
    closed = true;
  };
  const isClosed = () => closed;
  return { setController, safeEnqueue, safeClose, safeError, markClosed, isClosed };
}