"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DEFAULT_WEBSOCKET_USER_AGENT = exports.MAX_SOCKET_PAYLOAD_BYTES = void 0;
exports.buildClientUserAgent = buildClientUserAgent;
exports.connectWebSocket = connectWebSocket;
const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
/**
 * Maximum websocket frame size, in bytes, for sockets on both ends of the
 * editor <-> dev server connection. 100 MiB matches the `ws` library default;
 * it is set explicitly so the limit is a deliberate choice rather than an
 * inherited default. Inbound frames over the limit make `ws` close that
 * single socket with 1009 (Message Too Big).
 *
 * Only applies where `ws` is the implementation (Node). Browsers ignore the
 * option and don't enforce a receive limit.
 */
exports.MAX_SOCKET_PAYLOAD_BYTES = 100 * 1024 * 1024;
/**
 * Default User-Agent for Node-originated WebSocket handshakes. The `ws` client
 * sends no User-Agent by default (unlike browsers, axios, or undici's fetch),
 * and AWS WAF's managed common rule set blocks UA-less requests
 * (`NoUserAgent_HEADER`) with a 403 at the ALB. A non-empty UA keeps the
 * handshake from being rejected; callers may override with a more specific,
 * versioned identity. Ignored by browsers (native WebSocket sets its own UA).
 */
exports.DEFAULT_WEBSOCKET_USER_AGENT = 'superblocks-client';
/**
 * Build a client User-Agent of the form `component/version`, or bare `component`
 * when no version is supplied. Single source of truth for the identity strings
 * Node WebSocket clients (CLI, dev server, ...) send on the handshake.
 */
function buildClientUserAgent(component, version) {
    return version ? `${component}/${version}` : component;
}
/**
 * If the connection is not established within the timeout, the promise will be rejected.
 * This can happen with bad network conditions, but is very rare.
 */
function connectWebSocket(wsUrl, options = {}) {
    const { protocol, timeout = 30_000, headers } = options;
    return new Promise((resolve, reject) => {
        const ws = new isomorphic_ws_1.default(wsUrl, protocol, {
            maxPayload: exports.MAX_SOCKET_PAYLOAD_BYTES,
            headers: { 'User-Agent': exports.DEFAULT_WEBSOCKET_USER_AGENT, ...headers }
        });
        const timeoutId = setTimeout(() => {
            reject(new Error('[internal] WebSocket connection timeout'));
        }, timeout);
        ws.addEventListener('open', () => {
            clearTimeout(timeoutId);
            // Resolve the promise with the WebSocket instance when the connection is open
            resolve(ws);
        });
        ws.addEventListener('error', (event) => {
            clearTimeout(timeoutId);
            // Wrap browser WebSocket errors with [internal] tag so they can be filtered
            // from Clark's context (raw browser errors don't have useful stack traces)
            const message = 'message' in event && typeof event.message === 'string' ? event.message : 'WebSocket connection failed';
            reject(new Error(`[internal] ${message}`));
        });
    });
}
//# sourceMappingURL=util.js.map