@wirebench/engine 2.1.1

package/dist/grpc/send.js

@@ -0,0 +1,435 @@
+/**
+ * Sending one gRPC call over HTTP/2 with Node's `http2` module.
+ *
+ * gRPC is HTTP/2 with a fixed shape: a `POST` to `/<service>/<method>`, `content-type:
+ * application/grpc`, `te: trailers`, each message length-prefixed in the body, and the outcome in
+ * `grpc-status`/`grpc-message` trailers (or in the headers, for a "trailers-only" response). The
+ * REST transport's HTTP client hides trailers and buffers bodies, which is exactly what a server
+ * stream must not have, so this module speaks HTTP/2 directly. It knows nothing about protobuf:
+ * messages arrive and leave as bytes, and `call.ts` is where the codec meets the wire.
+ *
+ * A non-`OK` status is a result, not an error — the user asked what the server would say, and it
+ * said `NOT_FOUND`. Only a failure to get an answer at all (connection, TLS, an abort, a malformed
+ * stream) throws.
+ */
+import { Buffer } from 'node:buffer';
+import http2 from 'node:http2';
+import { gunzipSync, inflateSync } from 'node:zlib';
+import { GrpcError } from '../errors.js';
+import { toHttpError } from '../http/errors.js';
+import { captureSslInfo } from '../http/tls.js';
+import { encodeGrpcFrame, GrpcFrameParser } from './framing.js';
+import { grpcMethodPath } from './model.js';
+import { decodeGrpcMessage, formatGrpcTimeout, grpcStatusName } from './status.js';
+import { parseGrpcTarget } from './target.js';
+export { parseGrpcTarget } from './target.js';
+/** Headers no metadata row may set: the protocol owns them. */
+const RESERVED_HEADERS = new Set(['te', 'content-type', 'grpc-timeout', 'grpc-encoding', 'grpc-accept-encoding']);
+/** The `authorization` or custom header credentials become, as the HTTP transport spells them. */
+function authHeaders(auth) {
+    if (auth === undefined) {
+        return {};
+    }
+    switch (auth.type) {
+        case 'bearer':
+            return { authorization: `${auth.scheme ?? 'Bearer'} ${auth.token}` };
+        case 'oauth2':
+            return { authorization: `Bearer ${auth.accessToken}` };
+        case 'api-key':
+            return { [auth.name.toLowerCase()]: auth.value };
+        case 'basic':
+            return { authorization: `Basic ${Buffer.from(`${auth.username}:${auth.password}`, 'utf8').toString('base64')}` };
+        default:
+            throw new GrpcError('grpc-auth-unsupported', 'NTLM cannot authenticate a gRPC call; it is an HTTP/1.1 connection handshake.', {
+                details: { type: auth.type },
+            });
+    }
+}
+/** Builds the request headers: protocol first, then host defaults, credentials, and the user's rows last. */
+export function buildGrpcHeaders(input, target) {
+    const headers = {
+        ':method': 'POST',
+        ':scheme': target.tls ? 'https' : 'http',
+        ':authority': target.authority,
+        ':path': grpcMethodPath(input.service, input.method),
+        'content-type': 'application/grpc+proto',
+        te: 'trailers',
+        'grpc-accept-encoding': 'identity,gzip,deflate',
+        'grpc-timeout': formatGrpcTimeout(input.timeoutMs),
+    };
+    for (const [name, value] of Object.entries(input.defaultMetadata ?? {})) {
+        headers[name.toLowerCase()] = value;
+    }
+    for (const [name, value] of Object.entries(authHeaders(input.auth))) {
+        headers[name] = value;
+    }
+    for (const row of input.metadata) {
+        if (!row.enabled || row.name.trim() === '') {
+            continue;
+        }
+        const name = row.name.trim().toLowerCase();
+        if (name.startsWith(':') || RESERVED_HEADERS.has(name)) {
+            continue;
+        }
+        headers[name] = row.value;
+    }
+    return headers;
+}
+function headerText(headers) {
+    return `${Object.entries(headers)
+        .map(([name, value]) => `${name}: ${value}`)
+        .join('\r\n')}\r\n\r\n`;
+}
+/** Flattens Node's incoming headers to one string per name, dropping pseudo-headers. */
+function flatten(headers) {
+    const out = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.startsWith(':') || value === undefined) {
+            continue;
+        }
+        out[name] = Array.isArray(value) ? value.join(', ') : String(value);
+    }
+    return out;
+}
+/** The gRPC status the specification says an HTTP status without a `grpc-status` maps to. */
+function statusFromHttp(httpStatus) {
+    switch (httpStatus) {
+        case 400:
+            return 13;
+        case 401:
+            return 16;
+        case 403:
+            return 7;
+        case 404:
+            return 12;
+        case 429:
+        case 502:
+        case 503:
+        case 504:
+            return 14;
+        default:
+            return 2;
+    }
+}
+function decompress(payload, encoding) {
+    switch ((encoding ?? 'identity').toLowerCase()) {
+        case 'identity':
+            return payload;
+        case 'gzip':
+            return new Uint8Array(gunzipSync(payload));
+        case 'deflate':
+            return new Uint8Array(inflateSync(payload));
+        default:
+            throw new GrpcError('grpc-encoding-unsupported', `The server compressed the response with "${encoding ?? ''}", which this client cannot read`, {
+                details: { encoding },
+            });
+    }
+}
+function concat(parts) {
+    const total = parts.reduce((sum, part) => sum + part.byteLength, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.byteLength;
+    }
+    return out;
+}
+function connectOptions(input, target) {
+    const tls = input.tlsOptions;
+    return {
+        ...(input.localAddress !== undefined ? { localAddress: input.localAddress } : {}),
+        ...(target.tls
+            ? {
+                ...(tls?.rejectUnauthorized !== undefined ? { rejectUnauthorized: tls.rejectUnauthorized } : {}),
+                ...(tls?.ca !== undefined ? { ca: [...tls.ca] } : {}),
+                ...(tls?.cert !== undefined ? { cert: tls.cert } : {}),
+                ...(tls?.key !== undefined ? { key: tls.key } : {}),
+                ...(tls?.passphrase !== undefined ? { passphrase: tls.passphrase } : {}),
+                ...(tls?.minVersion !== undefined ? { minVersion: tls.minVersion } : {}),
+                servername: tls?.servername ?? (/^[\d.]+$|:/.test(target.host) ? '' : target.host),
+                ALPNProtocols: ['h2'],
+            }
+            : {}),
+    };
+}
+/**
+ * Sends one gRPC call and collects every response message and the final status.
+ *
+ * Client-streaming and bidirectional methods are sent in "batch" form: every request message is
+ * written, the request side is closed, and the responses are read until the server ends the stream.
+ * {@link GrpcSendInput.onOpen} turns that into an interactive call instead, where the caller keeps
+ * pushing messages until it half-closes.
+ *
+ * {@link GrpcSendInput.onHeaders} and {@link GrpcSendInput.onMessage} report the initial metadata
+ * and each response message as they arrive, for a caller that shows a stream while it runs.
+ *
+ * @throws HttpError for a connection, DNS, TLS or abort failure, with the HTTP transport's codes;
+ * GrpcError `grpc-target-invalid`, `grpc-auth-unsupported`, `grpc-stream-malformed`,
+ * `grpc-encoding-unsupported`, `grpc-message-too-large`, `grpc-stream-closed`
+ */
+export async function sendGrpc(input) {
+    const target = parseGrpcTarget(input.target, input.tls);
+    const now = input.now ?? (() => performance.now());
+    const startedAtMs = now();
+    const startedAt = new Date().toISOString();
+    const requestHeaders = buildGrpcHeaders(input, target);
+    // What was actually sent, which in interactive mode grows after the call opens; the exchange
+    // reports these rather than `input.messages` so its record and its raw bytes stay the same thing.
+    const sent = [...input.messages];
+    const sentFrames = sent.map((message) => encodeGrpcFrame(message));
+    const origin = `${target.tls ? 'https' : 'http'}://${target.authority}`;
+    const session = http2.connect(origin, connectOptions(input, target));
+    let connectMs;
+    let tlsInfo;
+    session.once('connect', () => {
+        connectMs = now() - startedAtMs;
+        // `session.socket` is a Proxy that answers property reads but not the `in` operator.
+        const socket = session.socket;
+        if (target.tls && typeof socket?.getPeerCertificate === 'function') {
+            tlsInfo = captureSslInfo(socket);
+        }
+    });
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let stream;
+        let deadlineHit = false;
+        let userAborted = false;
+        let headersAt;
+        let responseHeaders = {};
+        let httpStatus = 0;
+        let trailers = {};
+        const parser = new GrpcFrameParser();
+        let sessionError;
+        const rawFrames = [];
+        const messages = [];
+        let received = 0;
+        let truncated = false;
+        let encoding;
+        const cleanup = () => {
+            clearTimeout(deadline);
+            input.signal?.removeEventListener('abort', onAbort);
+            session.close();
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error instanceof GrpcError) {
+                reject(error);
+                return;
+            }
+            reject(toHttpError(error, { userAborted, deadlineHit: false, host: target.authority }));
+        };
+        const finish = (local) => {
+            if (settled)
+                return;
+            settled = true;
+            const endMs = now();
+            cleanup();
+            let status;
+            let statusMessage;
+            let statusSource;
+            const trailerStatus = trailers['grpc-status'];
+            const headerStatus = responseHeaders['grpc-status'];
+            if (local !== undefined) {
+                status = local.status;
+                statusMessage = local.message;
+                statusSource = 'local';
+            }
+            else if (trailerStatus !== undefined) {
+                status = Number(trailerStatus);
+                statusMessage = trailers['grpc-message'];
+                statusSource = 'trailers';
+            }
+            else if (headerStatus !== undefined) {
+                status = Number(headerStatus);
+                statusMessage = responseHeaders['grpc-message'];
+                statusSource = 'headers';
+            }
+            else if (httpStatus !== 200) {
+                status = statusFromHttp(httpStatus);
+                statusMessage = `HTTP status ${String(httpStatus)} without a grpc-status`;
+                statusSource = 'http';
+            }
+            else {
+                status = 2;
+                statusMessage = 'The server ended the stream without a grpc-status';
+                statusSource = 'http';
+            }
+            if (Number.isNaN(status)) {
+                status = 2;
+                statusMessage = `Unreadable grpc-status "${trailerStatus ?? headerStatus ?? ''}"`;
+            }
+            const decodedMessage = statusMessage === undefined ? undefined : decodeGrpcMessage(statusMessage);
+            const responseText = `HTTP/2 ${String(httpStatus)}\r\n${headerText(responseHeaders)}`;
+            const trailerText = Object.keys(trailers).length > 0 ? `\r\n${headerText(trailers)}` : '';
+            const totalMs = endMs - startedAtMs;
+            resolve({
+                request: {
+                    authority: target.authority,
+                    path: requestHeaders[':path'] ?? '',
+                    headers: requestHeaders,
+                    messages: sent,
+                },
+                httpStatus,
+                headers: responseHeaders,
+                trailers,
+                status,
+                statusName: grpcStatusName(status),
+                ...(decodedMessage !== undefined && decodedMessage !== '' ? { statusMessage: decodedMessage } : {}),
+                statusSource,
+                messages,
+                ...(encoding !== undefined && encoding !== 'identity' ? { encoding } : {}),
+                truncated,
+                timings: {
+                    startedAt,
+                    totalMs,
+                    ...(connectMs !== undefined ? { connectMs } : {}),
+                    ...(headersAt !== undefined ? { ttfbMs: headersAt - startedAtMs, downloadMs: endMs - headersAt } : {}),
+                },
+                ...(tlsInfo !== undefined ? { tls: tlsInfo } : {}),
+                rawRequest: concat([new TextEncoder().encode(headerText(requestHeaders)), ...sentFrames]),
+                rawResponse: concat([
+                    new TextEncoder().encode(responseText),
+                    ...rawFrames,
+                    new TextEncoder().encode(trailerText),
+                ]),
+                durationMs: totalMs,
+            });
+        };
+        const onAbort = () => {
+            userAborted = true;
+            stream?.close(http2.constants.NGHTTP2_CANCEL);
+            fail(new Error('aborted'));
+        };
+        const deadline = setTimeout(() => {
+            deadlineHit = true;
+            stream?.close(http2.constants.NGHTTP2_CANCEL);
+            finish({
+                status: 4,
+                message: `Deadline of ${formatGrpcTimeout(input.timeoutMs)} exceeded before the server answered`,
+            });
+        }, input.timeoutMs);
+        if (input.signal?.aborted === true) {
+            onAbort();
+            return;
+        }
+        input.signal?.addEventListener('abort', onAbort, { once: true });
+        session.on('error', (error) => {
+            sessionError = error;
+            fail(error);
+        });
+        session.on('close', () => {
+            if (!settled && !deadlineHit) {
+                fail(new GrpcError('grpc-stream-malformed', 'The connection closed before the call completed', {
+                    details: { httpStatus },
+                }));
+            }
+        });
+        const outgoing = { ...requestHeaders };
+        try {
+            stream = session.request(outgoing);
+        }
+        catch (error) {
+            fail(error);
+            return;
+        }
+        // A refused connection or a failed handshake reaches the stream as "the pending stream has been
+        // cancelled" as well as the session as the real cause; wait a tick so the cause wins.
+        stream.on('error', (error) => {
+            setImmediate(() => fail(sessionError ?? error));
+        });
+        stream.on('response', (headers) => {
+            headersAt = now();
+            httpStatus = Number(headers[':status'] ?? 0);
+            responseHeaders = flatten(headers);
+            encoding = responseHeaders['grpc-encoding'];
+            const contentType = responseHeaders['content-type'] ?? '';
+            if (httpStatus === 200 && !contentType.toLowerCase().startsWith('application/grpc')) {
+                fail(new GrpcError('grpc-stream-malformed', `The server answered with "${contentType}" rather than application/grpc; is ${target.authority} a gRPC server?`, {
+                    details: { contentType, httpStatus },
+                }));
+                return;
+            }
+            input.onHeaders?.(responseHeaders, httpStatus);
+        });
+        stream.on('data', (chunk) => {
+            if (settled)
+                return;
+            rawFrames.push(new Uint8Array(chunk));
+            try {
+                for (const frame of parser.push(new Uint8Array(chunk))) {
+                    received += frame.payload.byteLength;
+                    if (input.maxSizeBytes !== undefined && received > input.maxSizeBytes) {
+                        truncated = true;
+                        break;
+                    }
+                    const message = frame.compressed ? decompress(frame.payload, encoding) : frame.payload;
+                    messages.push(message);
+                    input.onMessage?.(message, messages.length - 1);
+                }
+            }
+            catch (error) {
+                fail(error);
+                return;
+            }
+            if (truncated) {
+                stream?.close(http2.constants.NGHTTP2_CANCEL);
+                finish();
+            }
+        });
+        stream.on('trailers', (headers) => {
+            trailers = flatten(headers);
+        });
+        stream.on('end', () => {
+            if (parser.pending > 0 && !truncated) {
+                fail(new GrpcError('grpc-stream-malformed', `The stream ended in the middle of a message (${String(parser.pending)} bytes left over)`, {
+                    details: { pending: parser.pending },
+                }));
+                return;
+            }
+            finish();
+        });
+        for (const frame of sentFrames) {
+            stream.write(Buffer.from(frame));
+        }
+        if (input.onOpen === undefined) {
+            stream.end();
+            return;
+        }
+        // Interactive: the request side stays open until the caller half-closes, the deadline passes or
+        // the signal aborts. `settled` covers all three, so a handle held past the end is inert rather
+        // than writing to a dead stream.
+        let halfClosed = false;
+        const open = stream;
+        try {
+            input.onOpen({
+                write: (message) => {
+                    if (settled || halfClosed) {
+                        throw new GrpcError('grpc-stream-closed', 'The request side of this call is already closed', {
+                            details: { halfClosed, settled },
+                        });
+                    }
+                    sent.push(message);
+                    const frame = encodeGrpcFrame(message);
+                    sentFrames.push(frame);
+                    open.write(Buffer.from(frame));
+                },
+                end: () => {
+                    if (halfClosed)
+                        return;
+                    halfClosed = true;
+                    if (!settled) {
+                        open.end();
+                    }
+                },
+                isOpen: () => !settled && !halfClosed,
+            });
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+}

package/dist/grpc/shape.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The pure shape rules of a gRPC method and target: what a kind means, how a method's `:path` is
+ * spelled, and whether an address implies TLS.
+ *
+ * A leaf on purpose. `model.ts` needs `project/paths.js` for its slugs, and that reaches
+ * `node:path`, which a renderer bundle cannot have — so the handful of rules the editor also needs
+ * live here, with no imports at all, and `model.ts` re-exports them so nothing else moved.
+ */
+/**
+ * The four shapes a gRPC method can take, as the `.proto` declares them with the `stream` keyword.
+ * Recorded on the request so the editor knows how many messages to expect on each side even when
+ * the definition is not to hand.
+ */
+export type GrpcMethodKind = 'unary' | 'server-streaming' | 'client-streaming' | 'bidi-streaming';
+/** Which server-reflection protocol to speak; `auto` tries v1 and falls back to v1alpha. */
+export type GrpcReflectionVersion = 'auto' | 'v1' | 'v1alpha';
+/** The versions a user can pick, in the order the selector offers them. */
+export declare const GRPC_REFLECTION_VERSIONS: readonly GrpcReflectionVersion[];
+/** The HTTP/2 `:path` of a method call: `/<service>/<method>`. */
+export declare function grpcMethodPath(service: string, method: string): string;
+/** Whether the client side of a method sends a stream, so the message text is an array. */
+export declare function clientStreams(kind: GrpcMethodKind): boolean;
+/** Whether the server side of a method answers with a stream. */
+export declare function serverStreams(kind: GrpcMethodKind): boolean;
+/**
+ * Whether a target implies TLS when the API has not said: an explicit `grpcs://`/`https://` scheme,
+ * or port 443. Anything else defaults to plaintext, as `grpcurl` does.
+ */
+export declare function defaultTlsFor(target: string): boolean;

package/dist/grpc/shape.js

@@ -0,0 +1,36 @@
+/**
+ * The pure shape rules of a gRPC method and target: what a kind means, how a method's `:path` is
+ * spelled, and whether an address implies TLS.
+ *
+ * A leaf on purpose. `model.ts` needs `project/paths.js` for its slugs, and that reaches
+ * `node:path`, which a renderer bundle cannot have — so the handful of rules the editor also needs
+ * live here, with no imports at all, and `model.ts` re-exports them so nothing else moved.
+ */
+/** The versions a user can pick, in the order the selector offers them. */
+export const GRPC_REFLECTION_VERSIONS = ['auto', 'v1', 'v1alpha'];
+/** The HTTP/2 `:path` of a method call: `/<service>/<method>`. */
+export function grpcMethodPath(service, method) {
+    return `/${service}/${method}`;
+}
+/** Whether the client side of a method sends a stream, so the message text is an array. */
+export function clientStreams(kind) {
+    return kind === 'client-streaming' || kind === 'bidi-streaming';
+}
+/** Whether the server side of a method answers with a stream. */
+export function serverStreams(kind) {
+    return kind === 'server-streaming' || kind === 'bidi-streaming';
+}
+/**
+ * Whether a target implies TLS when the API has not said: an explicit `grpcs://`/`https://` scheme,
+ * or port 443. Anything else defaults to plaintext, as `grpcurl` does.
+ */
+export function defaultTlsFor(target) {
+    const trimmed = target.trim().toLowerCase();
+    if (trimmed.startsWith('grpcs://') || trimmed.startsWith('https://')) {
+        return true;
+    }
+    if (trimmed.startsWith('grpc://') || trimmed.startsWith('http://')) {
+        return false;
+    }
+    return /:443$/.test(trimmed);
+}

package/dist/grpc/status.d.ts

@@ -0,0 +1,21 @@
+/**
+ * gRPC status codes, as the protocol's status specification numbers and names them, and the
+ * `grpc-message` percent-encoding that carries a status message in an HTTP/2 trailer.
+ */
+/** The seventeen status codes. `0` is the only success. */
+export declare const GRPC_STATUS_NAMES: Readonly<Record<number, string>>;
+/** The name of a status code, or `UNKNOWN (n)` for a number the specification does not define. */
+export declare function grpcStatusName(code: number): string;
+/**
+ * Decodes a `grpc-message` trailer value. The specification percent-encodes anything outside
+ * printable ASCII; a malformed sequence is kept as-is rather than failing the whole response, since
+ * the message is for a person to read.
+ */
+export declare function decodeGrpcMessage(value: string): string;
+/** Percent-encodes a status message for a `grpc-message` trailer, as a server would. */
+export declare function encodeGrpcMessage(value: string): string;
+/**
+ * Formats a deadline as a `grpc-timeout` header value: the largest unit that keeps the number to
+ * at most eight digits, as the specification requires.
+ */
+export declare function formatGrpcTimeout(timeoutMs: number): string;

package/dist/grpc/status.js

@@ -0,0 +1,62 @@
+/**
+ * gRPC status codes, as the protocol's status specification numbers and names them, and the
+ * `grpc-message` percent-encoding that carries a status message in an HTTP/2 trailer.
+ */
+/** The seventeen status codes. `0` is the only success. */
+export const GRPC_STATUS_NAMES = Object.freeze({
+    0: 'OK',
+    1: 'CANCELLED',
+    2: 'UNKNOWN',
+    3: 'INVALID_ARGUMENT',
+    4: 'DEADLINE_EXCEEDED',
+    5: 'NOT_FOUND',
+    6: 'ALREADY_EXISTS',
+    7: 'PERMISSION_DENIED',
+    8: 'RESOURCE_EXHAUSTED',
+    9: 'FAILED_PRECONDITION',
+    10: 'ABORTED',
+    11: 'OUT_OF_RANGE',
+    12: 'UNIMPLEMENTED',
+    13: 'INTERNAL',
+    14: 'UNAVAILABLE',
+    15: 'DATA_LOSS',
+    16: 'UNAUTHENTICATED',
+});
+/** The name of a status code, or `UNKNOWN (n)` for a number the specification does not define. */
+export function grpcStatusName(code) {
+    return GRPC_STATUS_NAMES[code] ?? `UNKNOWN (${String(code)})`;
+}
+/**
+ * Decodes a `grpc-message` trailer value. The specification percent-encodes anything outside
+ * printable ASCII; a malformed sequence is kept as-is rather than failing the whole response, since
+ * the message is for a person to read.
+ */
+export function decodeGrpcMessage(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+/** Percent-encodes a status message for a `grpc-message` trailer, as a server would. */
+export function encodeGrpcMessage(value) {
+    return Array.from(new TextEncoder().encode(value), (byte) => byte >= 0x20 && byte <= 0x7e && byte !== 0x25
+        ? String.fromCharCode(byte)
+        : `%${byte.toString(16).toUpperCase().padStart(2, '0')}`).join('');
+}
+/**
+ * Formats a deadline as a `grpc-timeout` header value: the largest unit that keeps the number to
+ * at most eight digits, as the specification requires.
+ */
+export function formatGrpcTimeout(timeoutMs) {
+    const ms = Math.max(1, Math.round(timeoutMs));
+    if (ms < 100_000_000) {
+        return `${String(ms)}m`;
+    }
+    const seconds = Math.ceil(ms / 1000);
+    if (seconds < 100_000_000) {
+        return `${String(seconds)}S`;
+    }
+    return `${String(Math.ceil(seconds / 3600))}H`;
+}

package/dist/grpc/target.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Reading a gRPC target as the user typed it. Pure, so the renderer can show the effective
+ * authority beside the field through the browser-safe `@wirebench/engine/grpc` subpath and agree
+ * with what the transport connects to.
+ */
+/** A parsed `host:port` target. */
+export interface GrpcTarget {
+    readonly host: string;
+    readonly port: number;
+    /** `host:port`, brackets kept around an IPv6 literal. */
+    readonly authority: string;
+    readonly tls: boolean;
+}
+/**
+ * Parses what the user typed as a target: `host:port`, `[::1]:50051`, or a URL whose scheme
+ * (`grpc`, `grpcs`, `http`, `https`, `dns`) settles TLS. Without a port, TLS implies 443 and plain
+ * implies 80, which is what an HTTP-shaped target means.
+ *
+ * @throws GrpcError `grpc-target-invalid`
+ */
+export declare function parseGrpcTarget(target: string, tls: boolean): GrpcTarget;

package/dist/grpc/target.js

@@ -0,0 +1,66 @@
+/**
+ * Reading a gRPC target as the user typed it. Pure, so the renderer can show the effective
+ * authority beside the field through the browser-safe `@wirebench/engine/grpc` subpath and agree
+ * with what the transport connects to.
+ */
+import { GrpcError } from '../errors.js';
+/**
+ * Parses what the user typed as a target: `host:port`, `[::1]:50051`, or a URL whose scheme
+ * (`grpc`, `grpcs`, `http`, `https`, `dns`) settles TLS. Without a port, TLS implies 443 and plain
+ * implies 80, which is what an HTTP-shaped target means.
+ *
+ * @throws GrpcError `grpc-target-invalid`
+ */
+export function parseGrpcTarget(target, tls) {
+    const trimmed = target.trim();
+    if (trimmed === '') {
+        throw new GrpcError('grpc-target-invalid', 'The target is empty. Enter the server as host:port.');
+    }
+    let useTls = tls;
+    let rest = trimmed;
+    const scheme = /^([a-z][a-z0-9+.-]*):\/\//i.exec(trimmed);
+    if (scheme !== null) {
+        const name = scheme[1].toLowerCase();
+        if (name === 'grpcs' || name === 'https') {
+            useTls = true;
+        }
+        else if (name === 'grpc' || name === 'http') {
+            useTls = false;
+        }
+        else if (name !== 'dns') {
+            throw new GrpcError('grpc-target-invalid', `"${scheme[1]}" is not a scheme a gRPC target can use`, {
+                details: { target },
+            });
+        }
+        rest = trimmed.slice(scheme[0].length).replace(/^\/+/, '');
+    }
+    // Cut at the first path, query or fragment character with a scan rather than a regex over the
+    // whole remainder.
+    for (let index = 0; index < rest.length; index += 1) {
+        const char = rest[index];
+        if (char === '/' || char === '?' || char === '#') {
+            rest = rest.slice(0, index);
+            break;
+        }
+    }
+    let url;
+    try {
+        url = new URL(`http://${rest}`);
+    }
+    catch (error) {
+        throw new GrpcError('grpc-target-invalid', `"${target}" is not a host:port target`, {
+            cause: error,
+            details: { target },
+        });
+    }
+    if (url.hostname === '' || url.username !== '' || url.password !== '') {
+        throw new GrpcError('grpc-target-invalid', `"${target}" is not a host:port target`, { details: { target } });
+    }
+    const port = url.port === '' ? (useTls ? 443 : 80) : Number(url.port);
+    return {
+        host: url.hostname.replace(/^\[|\]$/g, ''),
+        port,
+        authority: `${url.hostname}:${String(port)}`,
+        tls: useTls,
+    };
+}