export type SignalRpcOptions = {

baseUrl: string;

timeoutMs?: number;

maxResponseBytes?: number;

};

export type SignalRpcError = {

};

const DEFAULT_TIMEOUT_MS = 10_000;

const MAX_SIGNAL_HTTP_RESPONSE_BYTES = 1_048_576;

const DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES = 1_048_576;

const MAX_SIGNAL_SSE_BUFFER_BYTES = 1_048_576;

const MAX_SIGNAL_SSE_EVENT_DATA_BYTES = 1_048_576;

}

}

function normalizeSignalHttpResponseMaxBytes(value: number | undefined): number {

if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {

return DEFAULT_SIGNAL_HTTP_RESPONSE_MAX_BYTES;

}

return Math.floor(value);

}

function normalizeSignalSseTimeoutMs(timeoutMs: number): number | null {

if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {

return null;

}

return timeoutMs;

}

function requestSignalHttpText(

url: URL,

options: {

method: "GET" | "POST";

headers?: Record<string, string>;

body?: string;

timeoutMs: number;

maxResponseBytes?: number;

},

): Promise<SignalHttpResponse> {

assertSignalHttpProtocol(url, "HTTP");

cleanup();

resolve(response);

};

const maxResponseBytes = normalizeSignalHttpResponseMaxBytes(options.maxResponseBytes);

request = client.request(

url,

{

res.on("data", (chunk: Buffer | string) => {

const next = typeof chunk === "string" ? Buffer.from(chunk) : chunk;

totalBytes += next.byteLength;

if (totalBytes > MAX_SIGNAL_HTTP_RESPONSE_BYTES) {

if (totalBytes > maxResponseBytes) {

const error = new Error("Signal HTTP response exceeded size limit");

request?.destroy(error);

res.destroy(error);

},

body,

timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,

maxResponseBytes: opts.maxResponseBytes,

});

if (res.status === 201) {

return undefined as T;

let response: IncomingMessage | undefined;

let onAbort: () => void = () => {};

let request: ClientRequest;

const headerDeadline = setTimeout(() => {

const error = new Error(`Signal SSE connection timed out after ${timeoutMs}ms`);

response?.destroy(error);

request.destroy(error);

rejectOnce(error);

}, timeoutMs);

headerDeadline.unref?.();

const effectiveTimeoutMs = normalizeSignalSseTimeoutMs(timeoutMs);

const headerDeadline =

effectiveTimeoutMs === null

? undefined

: setTimeout(() => {

const error = new Error(

`Signal SSE connection timed out after ${effectiveTimeoutMs}ms`,

);

response?.destroy(error);

request.destroy(error);

rejectOnce(error);

}, effectiveTimeoutMs);

headerDeadline?.unref?.();

const cleanup = () => {

clearTimeout(headerDeadline);

if (headerDeadline) {

clearTimeout(headerDeadline);

}

abortSignal?.removeEventListener("abort", onAbort);

};

const rejectOnce = (error: unknown) => {

res.destroy();

return;

}

clearTimeout(headerDeadline);

if (headerDeadline) {

clearTimeout(headerDeadline);

}

settled = true;

response = res;

resolve({ response: res, cleanup });