@wirebench/engine 2.1.1

package/dist/grpc/proto/well-known.js

@@ -0,0 +1,143 @@
+/**
+ * The JSON mapping the protobuf specification gives the well-known types: a `Timestamp` is an
+ * RFC 3339 string, a `Duration` is `"1.5s"`, a `Struct` is the JSON object it represents, a wrapper
+ * is its bare value, an `Any` carries an `@type` beside the message's own fields. The parser
+ * itself knows only the field-by-field form (`{seconds, nanos}`), so the codec converts between
+ * the two here, on the way in and on the way out, field numbers rather than names because the
+ * bundled definitions do not spell the names the way a `.proto` on disk does.
+ */
+import { ProtoError } from '../../errors.js';
+/** The fully qualified names this module handles. */
+export const WELL_KNOWN_TYPES = new Set([
+    'google.protobuf.Timestamp',
+    'google.protobuf.Duration',
+    'google.protobuf.Struct',
+    'google.protobuf.Value',
+    'google.protobuf.ListValue',
+    'google.protobuf.NullValue',
+    'google.protobuf.Empty',
+    'google.protobuf.FieldMask',
+    'google.protobuf.Any',
+    'google.protobuf.DoubleValue',
+    'google.protobuf.FloatValue',
+    'google.protobuf.Int64Value',
+    'google.protobuf.UInt64Value',
+    'google.protobuf.Int32Value',
+    'google.protobuf.UInt32Value',
+    'google.protobuf.BoolValue',
+    'google.protobuf.StringValue',
+    'google.protobuf.BytesValue',
+]);
+const WRAPPERS = new Set([...WELL_KNOWN_TYPES].filter((name) => name.endsWith('Value') &&
+    name !== 'google.protobuf.Value' &&
+    name !== 'google.protobuf.ListValue' &&
+    name !== 'google.protobuf.NullValue'));
+/** Whether `fullName` is a wrapper type (`google.protobuf.StringValue` and its siblings). */
+export function isWrapperType(fullName) {
+    return WRAPPERS.has(fullName);
+}
+/** The sample the editor shows for a well-known type, or `undefined` for an ordinary message. */
+export function wellKnownSample(fullName) {
+    switch (fullName) {
+        case 'google.protobuf.Timestamp':
+            return '1970-01-01T00:00:00Z';
+        case 'google.protobuf.Duration':
+            return '0s';
+        case 'google.protobuf.Struct':
+        case 'google.protobuf.Empty':
+            return {};
+        case 'google.protobuf.Value':
+            return null;
+        case 'google.protobuf.ListValue':
+            return [];
+        case 'google.protobuf.FieldMask':
+            return '';
+        case 'google.protobuf.Any':
+            return { '@type': '' };
+        case 'google.protobuf.BoolValue':
+            return false;
+        case 'google.protobuf.StringValue':
+        case 'google.protobuf.BytesValue':
+        case 'google.protobuf.Int64Value':
+        case 'google.protobuf.UInt64Value':
+            return '';
+        case 'google.protobuf.DoubleValue':
+        case 'google.protobuf.FloatValue':
+        case 'google.protobuf.Int32Value':
+        case 'google.protobuf.UInt32Value':
+            return 0;
+        default:
+            return undefined;
+    }
+}
+function invalid(type, reason) {
+    return new ProtoError('grpc-message-invalid', `${type}: ${reason}`, { details: { type, reason } });
+}
+/** `{seconds, nanos}` from a JSON `Timestamp` string. */
+export function timestampFromJson(value) {
+    if (typeof value !== 'string') {
+        throw invalid('google.protobuf.Timestamp', 'expected an RFC 3339 string');
+    }
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (match === null) {
+        throw invalid('google.protobuf.Timestamp', `"${value}" is not an RFC 3339 timestamp`);
+    }
+    const millis = Date.parse(`${match[1]}${match[3]}`);
+    if (Number.isNaN(millis)) {
+        throw invalid('google.protobuf.Timestamp', `"${value}" is not a valid date`);
+    }
+    const fraction = match[2] === undefined ? '' : match[2].slice(1).padEnd(9, '0');
+    return { seconds: String(Math.floor(millis / 1000)), nanos: fraction === '' ? 0 : Number(fraction) };
+}
+/** A JSON `Timestamp` string from `{seconds, nanos}`. */
+export function timestampToJson(value) {
+    const seconds = Number(value.seconds ?? 0);
+    const nanos = Number(value.nanos ?? 0);
+    const iso = new Date(seconds * 1000).toISOString().slice(0, 19);
+    if (nanos === 0) {
+        return `${iso}Z`;
+    }
+    const fraction = String(nanos)
+        .padStart(9, '0')
+        .replace(/(?:000)+$/, '');
+    return `${iso}.${fraction}Z`;
+}
+/** `{seconds, nanos}` from a JSON `Duration` string such as `"1.5s"`. */
+export function durationFromJson(value) {
+    if (typeof value !== 'string') {
+        throw invalid('google.protobuf.Duration', 'expected a string such as "1.5s"');
+    }
+    const match = /^(-)?(\d+)(?:\.(\d{1,9}))?s$/.exec(value);
+    if (match === null) {
+        throw invalid('google.protobuf.Duration', `"${value}" is not a duration such as "1.5s"`);
+    }
+    const negative = match[1] === '-';
+    const seconds = BigInt(match[2] ?? '0');
+    const nanos = match[3] === undefined ? 0 : Number(match[3].padEnd(9, '0'));
+    return { seconds: `${negative ? '-' : ''}${seconds.toString()}`, nanos: negative ? -nanos : nanos };
+}
+/** A JSON `Duration` string from `{seconds, nanos}`. */
+export function durationToJson(value) {
+    const seconds = typeof value.seconds === 'string' || typeof value.seconds === 'number' ? String(value.seconds) : '0';
+    const nanos = Number(value.nanos ?? 0);
+    const negative = seconds.startsWith('-') || nanos < 0;
+    const absSeconds = seconds.replace(/^-/, '');
+    const absNanos = Math.abs(nanos);
+    const fraction = absNanos === 0
+        ? ''
+        : `.${String(absNanos)
+            .padStart(9, '0')
+            .replace(/(?:000)+$/, '')}`;
+    return `${negative ? '-' : ''}${absSeconds}${fraction}s`;
+}
+/** A JSON `FieldMask` string (`"a.b,c"`) as `{paths}`. */
+export function fieldMaskFromJson(value) {
+    if (typeof value !== 'string') {
+        throw invalid('google.protobuf.FieldMask', 'expected a comma-separated string of paths');
+    }
+    return { paths: value === '' ? [] : value.split(',').map((path) => path.trim()) };
+}
+/** `{paths}` as the JSON `FieldMask` string. */
+export function fieldMaskToJson(value) {
+    return Array.isArray(value.paths) ? value.paths.map(String).join(',') : '';
+}

package/dist/grpc/reconcile.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Reconciling a gRPC API against a schema it has been given again — a server re-describing itself,
+ * or the same `.proto` files re-read.
+ *
+ * The rule is the one "Update Definition" keeps for a WSDL: **nothing is ever deleted.** A method the
+ * schema no longer declares keeps its saved request, flagged {@link GrpcRequestDef.orphaned}, because
+ * a method that disappeared may mean "clean this up" or may mean the server was rebuilt wrong, and
+ * that is the user's call. A method that came back has the flag cleared. A method the API does not
+ * have yet gets a request, in the folder its service already owns or in a new one; what the user
+ * edited — a message, metadata, credentials, settings — is never touched.
+ *
+ * Pure: it returns the next API and the ids of what changed, and writes nothing.
+ */
+import type { IdGenerator } from '../project/model.js';
+import type { GrpcApi } from './model.js';
+import type { ProtoSet } from './proto/load.js';
+/** Options for {@link reconcileGrpcApi}. */
+export interface ReconcileGrpcApiOptions {
+    /** Mints ids for created folders and requests; injected by tests for determinism. */
+    readonly newId?: IdGenerator;
+}
+/** What {@link reconcileGrpcApi} did, in ids the caller can report or select. */
+export interface GrpcReconcileResult {
+    readonly api: GrpcApi;
+    /** Ids of requests created for methods the API did not have. */
+    readonly requestsAdded: readonly string[];
+    /** Ids of requests now flagged `orphaned` because their method is gone. */
+    readonly requestsOrphaned: readonly string[];
+    /** Ids of requests whose method is back, so the flag was cleared. */
+    readonly requestsRestored: readonly string[];
+    /** Ids of requests whose streaming shape changed, so `methodKind` was corrected. */
+    readonly requestsRetyped: readonly string[];
+    /** Ids of folders created for services the API did not have. */
+    readonly foldersAdded: readonly string[];
+}
+/**
+ * Brings `api` in line with `set`.
+ *
+ * @param api the API to reconcile; never mutated
+ * @param set the schema it has been given again
+ */
+export declare function reconcileGrpcApi(api: GrpcApi, set: ProtoSet, options?: ReconcileGrpcApiOptions): GrpcReconcileResult;

package/dist/grpc/reconcile.js

@@ -0,0 +1,153 @@
+/**
+ * Reconciling a gRPC API against a schema it has been given again — a server re-describing itself,
+ * or the same `.proto` files re-read.
+ *
+ * The rule is the one "Update Definition" keeps for a WSDL: **nothing is ever deleted.** A method the
+ * schema no longer declares keeps its saved request, flagged {@link GrpcRequestDef.orphaned}, because
+ * a method that disappeared may mean "clean this up" or may mean the server was rebuilt wrong, and
+ * that is the user's call. A method that came back has the flag cleared. A method the API does not
+ * have yet gets a request, in the folder its service already owns or in a new one; what the user
+ * edited — a message, metadata, credentials, settings — is never touched.
+ *
+ * Pure: it returns the next API and the ids of what changed, and writes nothing.
+ */
+import { uniqueSlug } from '../project/paths.js';
+import { createGrpcFolder, createGrpcRequest } from './model.js';
+import { describeServices } from './proto/describe.js';
+import { sampleMessageText } from './proto/sample.js';
+/** A method's identity across two schemas. */
+function methodKey(service, method) {
+    return `${service}/${method}`;
+}
+/** Every request under a folder tree, depth-first, with the folder holding it. */
+function walkRequests(folders) {
+    return folders.flatMap((folder) => [
+        ...folder.requests.map((request) => ({ folder, request })),
+        ...walkRequests(folder.folders),
+    ]);
+}
+/** A method's description: its leading comment, with a deprecation notice ahead of it. */
+function requestDescription(method) {
+    const parts = [method.deprecated === true ? '**Deprecated.**' : undefined, method.comment].filter((part) => part !== undefined && part !== '');
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * Brings `api` in line with `set`.
+ *
+ * @param api the API to reconcile; never mutated
+ * @param set the schema it has been given again
+ */
+export function reconcileGrpcApi(api, set, options = {}) {
+    const services = describeServices(set);
+    const declared = new Map();
+    for (const service of services) {
+        for (const method of service.methods) {
+            declared.set(methodKey(service.fullName, method.name), { service, method });
+        }
+    }
+    const requestsOrphaned = [];
+    const requestsRestored = [];
+    const requestsRetyped = [];
+    const kept = new Set();
+    /** Re-flags one request against the schema, leaving everything the user edited alone. */
+    const reconcileRequest = (request) => {
+        const found = declared.get(methodKey(request.service, request.method));
+        if (found === undefined) {
+            if (request.orphaned !== true) {
+                requestsOrphaned.push(request.id);
+                return { ...request, orphaned: true };
+            }
+            return request;
+        }
+        kept.add(methodKey(request.service, request.method));
+        let next = request;
+        if (next.orphaned === true) {
+            requestsRestored.push(next.id);
+            const { orphaned, ...rest } = next;
+            void orphaned;
+            next = rest;
+        }
+        if (next.methodKind !== found.method.kind) {
+            requestsRetyped.push(next.id);
+            next = { ...next, methodKind: found.method.kind };
+        }
+        return next;
+    };
+    const reconcileFolder = (folder) => ({
+        ...folder,
+        requests: folder.requests.map(reconcileRequest),
+        folders: folder.folders.map(reconcileFolder),
+    });
+    let next = {
+        ...api,
+        requests: api.requests.map(reconcileRequest),
+        folders: api.folders.map(reconcileFolder),
+    };
+    // Where a new request goes: the folder that already holds this service, anywhere in the tree.
+    const folderOfService = new Map();
+    for (const { folder, request } of walkRequests(next.folders)) {
+        if (!folderOfService.has(request.service)) {
+            folderOfService.set(request.service, folder.id);
+        }
+    }
+    const requestsAdded = [];
+    const foldersAdded = [];
+    const newRequests = new Map();
+    const rootFolderSlugs = new Set(next.folders.map((folder) => folder.slug.toLowerCase()));
+    for (const service of services) {
+        const missing = service.methods.filter((method) => !kept.has(methodKey(service.fullName, method.name)));
+        if (missing.length === 0) {
+            continue;
+        }
+        let folderId = folderOfService.get(service.fullName);
+        if (folderId === undefined) {
+            const slug = uniqueSlug(service.name, rootFolderSlugs);
+            rootFolderSlugs.add(slug.toLowerCase());
+            const description = [service.package !== '' ? `Package \`${service.package}\`.` : undefined, service.comment]
+                .filter((part) => part !== undefined && part !== '')
+                .join(' ');
+            const folder = createGrpcFolder(service.name, {
+                slug,
+                order: next.folders.length,
+                ...(options.newId !== undefined ? { newId: options.newId } : {}),
+                ...(description !== '' ? { description } : {}),
+            });
+            foldersAdded.push(folder.id);
+            next = { ...next, folders: [...next.folders, folder] };
+            folderId = folder.id;
+            folderOfService.set(service.fullName, folderId);
+        }
+        const into = newRequests.get(folderId) ?? [];
+        for (const method of missing) {
+            const description = requestDescription(method);
+            const request = createGrpcRequest(method.name, {
+                ...(options.newId !== undefined ? { newId: options.newId } : {}),
+                ...(description !== undefined ? { description } : {}),
+                service: service.fullName,
+                method: method.name,
+                methodKind: method.kind,
+                message: sampleMessageText(set, method.requestType),
+            });
+            requestsAdded.push(request.id);
+            into.push(request);
+        }
+        newRequests.set(folderId, into);
+    }
+    /** Appends the new requests of each folder, slugs and orders unique within it. */
+    const addInto = (folder) => {
+        const additions = newRequests.get(folder.id) ?? [];
+        const folders = folder.folders.map(addInto);
+        if (additions.length === 0) {
+            return { ...folder, folders };
+        }
+        const taken = new Set(folder.requests.map((request) => request.slug.toLowerCase()));
+        const numbered = additions.map((request, index) => {
+            const slug = uniqueSlug(request.name, taken);
+            taken.add(slug.toLowerCase());
+            return { ...request, slug, order: folder.requests.length + index };
+        });
+        return { ...folder, folders, requests: [...folder.requests, ...numbered] };
+    };
+    next = { ...next, folders: next.folders.map(addInto) };
+    return { api: next, requestsAdded, requestsOrphaned, requestsRestored, requestsRetyped, foldersAdded };
+}

package/dist/grpc/reflection/client.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Discovering a server's services over gRPC server reflection.
+ *
+ * A user who has the `.proto` files imports them; a user who has only an address asks the server
+ * what it serves. The protocol for that is `ServerReflectionInfo`, and although it is declared as a
+ * bidirectional stream, the exchange is strictly request/response per message and the client always
+ * knows what to ask for before it asks — so the whole discovery resolves as a short sequence of
+ * ordinary batch calls through {@link sendGrpc}, with no transport change and with trust, proxy,
+ * credentials and deadline behaving exactly as they do for a call the user sends by hand.
+ *
+ * The rounds are:
+ *
+ * 1. `list_services` — the service names the server exposes.
+ * 2. One `file_containing_symbol` per service. A well-behaved server answers each with the file
+ *    declaring the service *and* its transitive dependencies.
+ * 3. Whatever dependency is still missing, by `file_by_filename`, until nothing new arrives or the
+ *    round cap is reached — so a server that answers a dependency with another dependency cannot
+ *    keep the client asking forever.
+ */
+import type { ProtoSet } from '../proto/load.js';
+import type { GrpcSendInput } from '../send.js';
+import type { GrpcReflectionVersion } from './proto.js';
+export type { GrpcReflectionVersion } from './proto.js';
+/** Everything {@link reflectServices} needs: the transport half of a call, plus the version to speak. */
+export interface GrpcReflectInput extends Omit<GrpcSendInput, 'service' | 'method' | 'messages'> {
+    /** Which protocol version to use. Defaults to `auto`: v1 first, v1alpha if the server refuses it. */
+    readonly version?: GrpcReflectionVersion;
+    /** Cap on the dependency-chasing rounds. Defaults to 8. */
+    readonly maxRounds?: number;
+}
+/** What a server described of itself. */
+export interface GrpcReflectionResult {
+    /** The version that answered, which is what an `auto` discovery resolved to. */
+    readonly version: 'v1' | 'v1alpha';
+    /** The services the server exposes, reflection's own services excluded. */
+    readonly services: readonly string[];
+    /** Every descriptor collected, keyed by the file name its own header carries. */
+    readonly files: ReadonlyMap<string, Uint8Array>;
+    /** The files declaring the services, which the schema is loaded from. */
+    readonly roots: readonly string[];
+    /** Files something imports that the server never described, after the rounds ran out. */
+    readonly missing: readonly string[];
+}
+/** Whether a name is one of reflection's own services, which a discovered API has no use for. */
+export declare function isReflectionService(name: string): boolean;
+/**
+ * Asks a server what it serves.
+ *
+ * `auto` tries `grpc.reflection.v1` and falls back to `grpc.reflection.v1alpha` when the server
+ * refuses it, which is what a server predating the stable package does.
+ *
+ * @throws HttpError for a connection, DNS, TLS or abort failure; GrpcError
+ * `grpc-reflection-unsupported` when the server serves no reflection version this client knows,
+ * `grpc-reflection-failed` when it refuses a request; ProtoError `grpc-reflection-descriptor` when
+ * a descriptor it sent cannot be read
+ */
+export declare function reflectServices(input: GrpcReflectInput): Promise<GrpcReflectionResult>;
+/** What {@link reflectProtoSet} produced: the loaded schema and the discovery behind it. */
+export interface GrpcReflectedProtoSet extends GrpcReflectionResult {
+    readonly set: ProtoSet;
+}
+/**
+ * Discovers a server's services and resolves them into a loaded schema, which is the form the rest
+ * of the gRPC code — `describeServices`, the codec, `apiFromProtoSet` — already reads.
+ *
+ * @throws as {@link reflectServices}, plus ProtoError `grpc-reflection-incomplete` when the set the
+ * server described does not resolve and files it imports are missing from it, and `proto-unresolved`
+ * when it does not resolve for any other reason
+ */
+export declare function reflectProtoSet(input: GrpcReflectInput): Promise<GrpcReflectedProtoSet>;

package/dist/grpc/reflection/client.js

@@ -0,0 +1,197 @@
+/**
+ * Discovering a server's services over gRPC server reflection.
+ *
+ * A user who has the `.proto` files imports them; a user who has only an address asks the server
+ * what it serves. The protocol for that is `ServerReflectionInfo`, and although it is declared as a
+ * bidirectional stream, the exchange is strictly request/response per message and the client always
+ * knows what to ask for before it asks — so the whole discovery resolves as a short sequence of
+ * ordinary batch calls through {@link sendGrpc}, with no transport change and with trust, proxy,
+ * credentials and deadline behaving exactly as they do for a call the user sends by hand.
+ *
+ * The rounds are:
+ *
+ * 1. `list_services` — the service names the server exposes.
+ * 2. One `file_containing_symbol` per service. A well-behaved server answers each with the file
+ *    declaring the service *and* its transitive dependencies.
+ * 3. Whatever dependency is still missing, by `file_by_filename`, until nothing new arrives or the
+ *    round cap is reached — so a server that answers a dependency with another dependency cannot
+ *    keep the client asking forever.
+ */
+import { Buffer } from 'node:buffer';
+import { GrpcError } from '../../errors.js';
+import { decodeMessage, encodeMessage } from '../codec.js';
+import { sendGrpc } from '../send.js';
+import { grpcStatusName } from '../status.js';
+import { descriptorHeader, protoSetFromDescriptors } from './descriptors.js';
+import { REFLECTION_METHOD, REFLECTION_VERSIONS, reflectionPackage, reflectionProtoSet, reflectionServiceName, } from './proto.js';
+/** How many `file_by_filename` rounds to run before giving up on the files still missing. */
+const DEFAULT_MAX_ROUNDS = 8;
+/** `UNIMPLEMENTED`, which is what a server that does not know a reflection version answers with. */
+const UNIMPLEMENTED = 12;
+/** Whether a name is one of reflection's own services, which a discovered API has no use for. */
+export function isReflectionService(name) {
+    return REFLECTION_VERSIONS.some((version) => name === reflectionServiceName(version));
+}
+/** Whether an error says the server does not implement the reflection version that was tried. */
+function refusedVersion(error) {
+    return error instanceof GrpcError && error.code === 'grpc-reflection-unsupported';
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+/** The `bytes` of a descriptor field, which the codec hands over as base64 per the JSON mapping. */
+function descriptorBytes(value) {
+    const list = Array.isArray(value) ? value : [];
+    return list
+        .filter((entry) => typeof entry === 'string')
+        .map((entry) => new Uint8Array(Buffer.from(entry, 'base64')));
+}
+/** One round: every request goes out on one stream, and the responses come back in the same order. */
+async function exchange(input, version, set, requests) {
+    const pkg = reflectionPackage(version);
+    const exchanged = await sendGrpc({
+        ...input,
+        service: reflectionServiceName(version),
+        method: REFLECTION_METHOD,
+        messages: requests.map((request) => encodeMessage(set, `${pkg}.ServerReflectionRequest`, request)),
+    });
+    if (exchanged.status !== 0) {
+        const detail = exchanged.statusMessage === undefined ? '' : `: ${exchanged.statusMessage}`;
+        throw new GrpcError(exchanged.status === UNIMPLEMENTED ? 'grpc-reflection-unsupported' : 'grpc-reflection-failed', exchanged.status === UNIMPLEMENTED
+            ? `${input.target} does not serve ${reflectionServiceName(version)}${detail}`
+            : `${input.target} answered the reflection call with ${grpcStatusName(exchanged.status)}${detail}`, { details: { status: exchanged.status, version, service: reflectionServiceName(version) } });
+    }
+    return exchanged.messages.map((bytes) => decodeMessage(set, `${pkg}.ServerReflectionResponse`, bytes));
+}
+/**
+ * The `error_response` a server may answer an individual request with, as an error.
+ *
+ * A reflection error is reported inside the response rather than as the call's status, because one
+ * stream carries many requests; `UNIMPLEMENTED` here means the same thing it means in the trailers,
+ * so it feeds the version fallback the same way.
+ */
+function assertNoError(response, version, target) {
+    const error = response['error_response'];
+    if (error === undefined) {
+        return;
+    }
+    const record = asRecord(error);
+    const code = Number(record['error_code'] ?? 2);
+    const message = typeof record['error_message'] === 'string' ? record['error_message'] : '';
+    throw new GrpcError(code === UNIMPLEMENTED ? 'grpc-reflection-unsupported' : 'grpc-reflection-failed', `${target} refused a reflection request with ${grpcStatusName(code)}${message === '' ? '' : `: ${message}`}`, { details: { status: code, version } });
+}
+/** Runs every round against one version. */
+async function reflectWith(input, version) {
+    const set = reflectionProtoSet(version);
+    const [listed] = await exchange(input, version, set, [{ list_services: '' }]);
+    if (listed === undefined) {
+        throw new GrpcError('grpc-reflection-failed', `${input.target} answered the service list with no response`, {
+            details: { version },
+        });
+    }
+    assertNoError(asRecord(listed), version, input.target);
+    const entries = asRecord(asRecord(listed)['list_services_response'])['service'];
+    const services = (Array.isArray(entries) ? entries : [])
+        .map((entry) => asRecord(entry)['name'])
+        .filter((name) => typeof name === 'string' && name !== '')
+        .filter((name) => !isReflectionService(name));
+    const files = new Map();
+    const roots = [];
+    const collect = (response) => {
+        const record = asRecord(response);
+        assertNoError(record, version, input.target);
+        const descriptors = descriptorBytes(asRecord(record['file_descriptor_response'])['file_descriptor_proto']);
+        for (const bytes of descriptors) {
+            const { name } = descriptorHeader(bytes);
+            if (name !== '' && !files.has(name)) {
+                files.set(name, bytes);
+            }
+        }
+        return descriptors;
+    };
+    if (services.length > 0) {
+        const responses = await exchange(input, version, set, services.map((service) => ({ file_containing_symbol: service })));
+        for (const response of responses) {
+            // The file declaring the asked-for symbol comes first by convention; the rest are its imports.
+            const first = collect(response)[0];
+            if (first !== undefined) {
+                const { name } = descriptorHeader(first);
+                if (name !== '' && !roots.includes(name)) {
+                    roots.push(name);
+                }
+            }
+        }
+    }
+    const stillMissing = () => {
+        const wanted = new Set();
+        for (const bytes of files.values()) {
+            for (const dependency of descriptorHeader(bytes).dependencies) {
+                if (!files.has(dependency)) {
+                    wanted.add(dependency);
+                }
+            }
+        }
+        return [...wanted];
+    };
+    const maxRounds = input.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    let missing = stillMissing();
+    for (let round = 0; round < maxRounds && missing.length > 0; round += 1) {
+        const before = files.size;
+        const responses = await exchange(input, version, set, missing.map((name) => ({ file_by_filename: name })));
+        for (const response of responses) {
+            collect(response);
+        }
+        if (files.size === before) {
+            break;
+        }
+        missing = stillMissing();
+    }
+    return { version, services, files, roots: roots.length > 0 ? roots : [...files.keys()], missing };
+}
+/**
+ * Asks a server what it serves.
+ *
+ * `auto` tries `grpc.reflection.v1` and falls back to `grpc.reflection.v1alpha` when the server
+ * refuses it, which is what a server predating the stable package does.
+ *
+ * @throws HttpError for a connection, DNS, TLS or abort failure; GrpcError
+ * `grpc-reflection-unsupported` when the server serves no reflection version this client knows,
+ * `grpc-reflection-failed` when it refuses a request; ProtoError `grpc-reflection-descriptor` when
+ * a descriptor it sent cannot be read
+ */
+export async function reflectServices(input) {
+    const versions = input.version === undefined || input.version === 'auto' ? REFLECTION_VERSIONS : [input.version];
+    let refusal;
+    for (const version of versions) {
+        try {
+            return await reflectWith(input, version);
+        }
+        catch (error) {
+            if (!refusedVersion(error)) {
+                throw error;
+            }
+            refusal = error;
+        }
+    }
+    throw refusal;
+}
+/**
+ * Discovers a server's services and resolves them into a loaded schema, which is the form the rest
+ * of the gRPC code — `describeServices`, the codec, `apiFromProtoSet` — already reads.
+ *
+ * @throws as {@link reflectServices}, plus ProtoError `grpc-reflection-incomplete` when the set the
+ * server described does not resolve and files it imports are missing from it, and `proto-unresolved`
+ * when it does not resolve for any other reason
+ */
+export async function reflectProtoSet(input) {
+    const result = await reflectServices(input);
+    try {
+        return { ...result, set: protoSetFromDescriptors({ files: result.files, roots: result.roots }) };
+    }
+    catch (error) {
+        if (result.missing.length === 0) {
+            throw error;
+        }
+        throw new GrpcError('grpc-reflection-incomplete', `${input.target} did not describe ${result.missing.join(', ')}, which the files it did describe import`, { cause: error, details: { missing: [...result.missing], version: result.version } });
+    }
+}