@wirebench/engine 2.2.0 → 3.1.0-rc.1

package/dist/grpc/script-types.js

@@ -0,0 +1,149 @@
+/**
+ * A gRPC request's script types, from its method's messages (spec §Types, gRPC).
+ *
+ * The types describe the messages' JSON form as the engine reads and writes it (`grpc/codec.ts`):
+ * fields under their declared names, 64-bit integers and bytes as strings (bytes in base64), enums
+ * by name, and every field optional, since a field left at its default is not written. Each message
+ * type becomes one alias, so a recursive message is fine. The well-known types map to their JSON
+ * forms.
+ */
+import { describeMessage, describeMethod } from './proto/describe.js';
+import { propertyKey } from '../script/types/json-schema.js';
+const SCALARS = {
+    double: 'number',
+    float: 'number',
+    int32: 'number',
+    uint32: 'number',
+    sint32: 'number',
+    fixed32: 'number',
+    sfixed32: 'number',
+    int64: 'string',
+    uint64: 'string',
+    sint64: 'string',
+    fixed64: 'string',
+    sfixed64: 'string',
+    bool: 'boolean',
+    string: 'string',
+    bytes: 'string',
+};
+const WELL_KNOWN = {
+    'google.protobuf.Timestamp': 'string',
+    'google.protobuf.Duration': 'string',
+    'google.protobuf.FieldMask': 'string',
+    'google.protobuf.Empty': 'Record<string, never>',
+    'google.protobuf.Struct': 'Record<string, unknown>',
+    'google.protobuf.Value': 'unknown',
+    'google.protobuf.ListValue': 'unknown[]',
+    'google.protobuf.Any': '{ "@type": string; [key: string]: unknown }',
+    'google.protobuf.DoubleValue': 'number',
+    'google.protobuf.FloatValue': 'number',
+    'google.protobuf.Int32Value': 'number',
+    'google.protobuf.UInt32Value': 'number',
+    'google.protobuf.Int64Value': 'string',
+    'google.protobuf.UInt64Value': 'string',
+    'google.protobuf.BoolValue': 'boolean',
+    'google.protobuf.StringValue': 'string',
+    'google.protobuf.BytesValue': 'string',
+};
+/** At most this many message types become aliases; beyond them a message is `unknown`. */
+const MAX_MESSAGES = 500;
+function aliasOf(fullName) {
+    return `WbMsg_${fullName.replace(/^\./, '').replace(/[^A-Za-z0-9_]/g, '_')}`;
+}
+function comment(text, indent) {
+    if (text === undefined || text.trim() === '')
+        return '';
+    return `${indent}/** ${text.trim().replace(/\*\//g, '*\\/').split(/\r?\n/).join(`\n${indent} * `)} */\n`;
+}
+class ProtoTypes {
+    set;
+    declared = new Map();
+    constructor(set) {
+        this.set = set;
+    }
+    message(fullName) {
+        const name = fullName.replace(/^\./, '');
+        const known = WELL_KNOWN[name];
+        if (known !== undefined)
+            return known;
+        const alias = aliasOf(name);
+        if (this.declared.has(alias))
+            return alias;
+        if (this.declared.size >= MAX_MESSAGES)
+            return 'unknown';
+        // Reserved first, so a message that refers to itself refers to the alias.
+        this.declared.set(alias, '');
+        let descriptor;
+        try {
+            descriptor = describeMessage(this.set, name);
+        }
+        catch {
+            this.declared.set(alias, `type ${alias} = unknown;\n`);
+            return alias;
+        }
+        const fields = descriptor.fields.map((field) => `${comment(field.comment, '  ')}  ${propertyKey(field.name)}?: ${this.field(field)};\n`);
+        this.declared.set(alias, `/** ${name} */\ntype ${alias} = ${fields.length === 0 ? 'Record<string, never>' : `{\n${fields.join('')}}`};\n`);
+        return alias;
+    }
+    value(field) {
+        switch (field.valueKind) {
+            case 'scalar':
+                return SCALARS[field.type] ?? 'unknown';
+            case 'enum':
+                return field.enumValues !== undefined && field.enumValues.length > 0
+                    ? field.enumValues.map((v) => JSON.stringify(v)).join(' | ')
+                    : 'string';
+            case 'message':
+            case 'map':
+                if (field.enumValues !== undefined && field.enumValues.length > 0) {
+                    return field.enumValues.map((v) => JSON.stringify(v)).join(' | ');
+                }
+                return SCALARS[field.type] ?? this.message(field.type);
+        }
+    }
+    field(field) {
+        const value = this.value(field);
+        if (field.valueKind === 'map') {
+            return `Record<string, ${value}>`;
+        }
+        if (field.repeated) {
+            return /^[A-Za-z0-9_$]+$/.test(value) ? `${value}[]` : `(${value})[]`;
+        }
+        return value;
+    }
+    declarations() {
+        return [...this.declared.values()].join('');
+    }
+}
+/** `WbRequestMessage` and `WbResponseMessage` for a method's input and output types. */
+export function grpcScriptTypes(set, inputType, outputType) {
+    if (set === undefined) {
+        return [
+            "// This request's proto definition is not at hand, so its messages are untyped.",
+            'type WbRequestMessage = unknown;',
+            'type WbResponseMessage = unknown;',
+            '',
+        ].join('\n');
+    }
+    const types = new ProtoTypes(set);
+    const request = types.message(inputType);
+    const response = types.message(outputType);
+    return [
+        types.declarations(),
+        `type WbRequestMessage = ${request};`,
+        `type WbResponseMessage = ${response};`,
+        '',
+    ].join('\n');
+}
+/** A gRPC method's request and response message types, when the set has the method. */
+export function grpcMessageTypes(set, service, method) {
+    if (set === undefined)
+        return undefined;
+    try {
+        const described = describeMethod(set, service, method);
+        return { input: described.requestType, output: described.responseType };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/grpc/scripting.d.ts

@@ -0,0 +1,34 @@
+import type { ProtocolScripting } from '../protocol/module.js';
+import type { HeaderPair } from '../script/model.js';
+import type { GrpcCallResult } from './call.js';
+import type { GrpcResolvedInput } from './run.js';
+export interface GrpcRequestSnapshot {
+    readonly protocol: 'grpc';
+    readonly target: string;
+    /** `package.Service/Method`; a script cannot change it. */
+    readonly method: string;
+    readonly metadata: readonly HeaderPair[];
+    /** The request message in its JSON form. */
+    readonly message: unknown;
+}
+export interface GrpcResponseSnapshot {
+    readonly protocol: 'grpc';
+    readonly status: {
+        readonly code: number;
+        readonly name: string;
+        readonly message: string;
+    };
+    readonly metadata: readonly HeaderPair[];
+    readonly trailers: readonly HeaderPair[];
+    /** The response message in its JSON form, when there was one. */
+    readonly message: unknown;
+    readonly durationMs: number;
+}
+export declare function grpcRequestSnapshot(input: GrpcResolvedInput, messageText: string): GrpcRequestSnapshot;
+export declare function applyGrpcSnapshot(input: GrpcResolvedInput, messageText: string, before: GrpcRequestSnapshot, after: GrpcRequestSnapshot): {
+    input: GrpcResolvedInput;
+    messageText: string;
+};
+export declare function grpcResponseSnapshot(result: GrpcCallResult): GrpcResponseSnapshot;
+/** gRPC's scripting facet. */
+export declare const grpcScripting: ProtocolScripting<GrpcRequestSnapshot, GrpcResponseSnapshot>;

package/dist/grpc/scripting.js

@@ -0,0 +1,147 @@
+/**
+ * What a script sees of a gRPC call and its answer (spec §3.4): the snapshots, the converters
+ * between a prepared call and a snapshot, the API's declarations, its sandbox-side source, and what
+ * the script rules check.
+ */
+import { z } from 'zod';
+import { headerPairSchema } from '../script/apply.js';
+import { entriesOf, pairsOf, recordPairs } from '../script/send.js';
+export function grpcRequestSnapshot(input, messageText) {
+    let message;
+    try {
+        message = JSON.parse(messageText);
+    }
+    catch {
+        message = messageText;
+    }
+    return {
+        protocol: 'grpc',
+        target: input.target,
+        method: `${input.service}/${input.method}`,
+        metadata: pairsOf(input.metadata),
+        message,
+    };
+}
+export function applyGrpcSnapshot(input, messageText, before, after) {
+    const changed = JSON.stringify(after.message) !== JSON.stringify(before.message);
+    return {
+        input: { ...input, metadata: entriesOf(after.metadata) },
+        messageText: changed ? JSON.stringify(after.message, null, 2) : messageText,
+    };
+}
+export function grpcResponseSnapshot(result) {
+    const first = result.responseMessages[0];
+    return {
+        protocol: 'grpc',
+        status: {
+            code: result.exchange.status,
+            name: result.exchange.statusName,
+            message: result.exchange.statusMessage ?? '',
+        },
+        metadata: recordPairs(result.exchange.headers),
+        trailers: recordPairs(result.exchange.trailers),
+        message: first?.json,
+        durationMs: result.exchange.durationMs,
+    };
+}
+const GRPC_PRE = `
+declare const request: {
+  readonly target: string;
+  readonly method: string;
+  readonly metadata: WbWritablePairs;
+  message: WbRequestMessage;
+};
+`;
+const GRPC_POST = `
+declare const request: {
+  readonly target: string;
+  readonly method: string;
+  readonly metadata: WbPairs;
+  readonly message: WbRequestMessage;
+};
+declare const response: {
+  readonly status: { readonly code: number; readonly name: string; readonly message: string };
+  readonly metadata: WbPairs;
+  readonly trailers: WbPairs;
+  readonly message: WbResponseMessage | undefined;
+  readonly durationMs: number;
+};
+`;
+const GRPC = String.raw `
+const grpcRequest = (snapshot, writable) => {
+  const data = {
+    target: snapshot.target,
+    method: snapshot.method,
+    metadata: snapshot.metadata.map(([n, v]) => [n, v]),
+    message: JSON.parse(JSON.stringify(snapshot.message === undefined ? null : snapshot.message)),
+  };
+  const refuse = (what) => () => { throw new TypeError('The ' + what + ' of a sent request cannot be changed'); };
+  const request = Object.freeze({
+    get target() { return data.target; },
+    get method() { return data.method; },
+    metadata: pairsApi(data.metadata, writable, 'metadata'),
+    get message() { return writable ? data.message : deepFreeze(data.message); },
+    set message(value) {
+      if (!writable) refuse('message')();
+      const text = JSON.stringify(value);
+      if (text === undefined) throw new TypeError('request.message must be a JSON value');
+      data.message = JSON.parse(text);
+    },
+  });
+  const snapshotOf = () => ({ protocol: 'grpc', target: data.target, method: data.method, metadata: data.metadata, message: data.message });
+  return { request, snapshotOf };
+};
+
+const grpcResponse = (snapshot) => deepFreeze({
+  status: snapshot.status,
+  metadata: pairsApi(snapshot.metadata.map(([n, v]) => [n, v]), false, 'metadata'),
+  trailers: pairsApi(snapshot.trailers.map(([n, v]) => [n, v]), false, 'metadata'),
+  message: snapshot.message,
+  durationMs: snapshot.durationMs,
+});
+
+if (input.phase === 'pre') {
+  const built = grpcRequest(input.request, true);
+  define('request', built.request);
+  state.request = built.snapshotOf;
+} else {
+  define('request', grpcRequest(input.request, false).request);
+  define('response', grpcResponse(input.response));
+}
+`;
+const requestSchema = z.object({
+    protocol: z.literal('grpc'),
+    target: z.string(),
+    method: z.string(),
+    metadata: z.array(headerPairSchema),
+    message: z.unknown(),
+});
+/** gRPC's scripting facet. */
+export const grpcScripting = {
+    declarations: (phase) => (phase === 'pre' ? GRPC_PRE : GRPC_POST),
+    reference: () => [
+        { title: 'gRPC: pre-request', declarations: GRPC_PRE },
+        { title: 'gRPC: post-response', declarations: GRPC_POST },
+    ],
+    prelude: () => GRPC,
+    requestSchema,
+    inspect(snapshot) {
+        return {
+            destination: snapshot.target,
+            fixed: snapshot.method,
+            pairs: snapshot.metadata,
+            lines: [],
+            texts: [snapshot.target, ...snapshot.metadata.flat(), JSON.stringify(snapshot.message) ?? ''],
+        };
+    },
+    /**
+     * A target never changes at all. Core's destination rule already holds a `host:port` target to
+     * that; one written as a URL (`grpcs://host:443`) would be allowed another path, so it is held
+     * here.
+     */
+    validate(before, after) {
+        return after.target === before.target
+            ? undefined
+            : { code: 'script-origin-change', message: 'A script cannot change the target of a gRPC call' };
+    },
+};

package/dist/grpc/send-input.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Turns a saved gRPC request plus the settings around it into the transport input of one call,
+ * everything but the encoded messages. The precedence between the layers of configuration is fixed
+ * here rather than in the host: request, then API, then project, then the user's preference.
+ */
+import type { SendAuth } from '../http/auth/send-auth.js';
+import type { KeyValueEntry } from '../http/entries.js';
+import type { TlsOptions } from '../http/types.js';
+import type { ProjectSettings } from '../project/model.js';
+import type { Preferences } from '../project/preferences.js';
+import type { GrpcMethodKind, GrpcRequestSettings } from './model.js';
+import type { GrpcSendInput } from './send.js';
+/** The parts of a gRPC request {@link toGrpcSendInput} reads. */
+export interface GrpcSendRequestInput {
+    readonly service: string;
+    readonly method: string;
+    readonly methodKind: GrpcMethodKind;
+    readonly metadata: readonly KeyValueEntry[];
+    readonly settings: GrpcRequestSettings;
+}
+/** Everything {@link toGrpcSendInput} needs beyond the request itself. */
+export interface ToGrpcSendInputArgs {
+    readonly request: GrpcSendRequestInput;
+    /** The API's effective target, environment override applied and properties expanded. */
+    readonly target: string;
+    readonly tls: boolean;
+    /** The API's own metadata rows, which a request row of the same key overrides. */
+    readonly apiMetadata?: readonly KeyValueEntry[];
+    /** The API's own settings, which a request inherits where it sets nothing. */
+    readonly apiSettings?: GrpcRequestSettings;
+    readonly preferences?: Preferences;
+    readonly projectSettings?: Pick<ProjectSettings, 'defaultTimeoutMs'>;
+    /** Resolved credentials; the host turns `secretRef`s into values and tokens into `oauth2`. */
+    readonly auth?: SendAuth;
+    readonly tlsOptions?: TlsOptions;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Builds the transport input for one gRPC call, everything but the encoded messages.
+ *
+ * The same request → API → project → preference ladder as a REST request, and the same TLS rule:
+ * the floor comes from preferences, and the host merges trust anchors, the client identity and the
+ * per-request trust decision on top. Metadata rows are the API's first and then the request's, so
+ * a repeated key resolves to the request's value on the wire.
+ */
+export declare function toGrpcSendInput(args: ToGrpcSendInputArgs): Omit<GrpcSendInput, 'messages'>;

package/dist/grpc/send-input.js

@@ -0,0 +1,42 @@
+/**
+ * Turns a saved gRPC request plus the settings around it into the transport input of one call,
+ * everything but the encoded messages. The precedence between the layers of configuration is fixed
+ * here rather than in the host: request, then API, then project, then the user's preference.
+ */
+import { inherited } from '../project/inherit.js';
+import { DEFAULT_PREFERENCES } from '../project/preferences.js';
+/**
+ * Builds the transport input for one gRPC call, everything but the encoded messages.
+ *
+ * The same request → API → project → preference ladder as a REST request, and the same TLS rule:
+ * the floor comes from preferences, and the host merges trust anchors, the client identity and the
+ * per-request trust decision on top. Metadata rows are the API's first and then the request's, so
+ * a repeated key resolves to the request's value on the wire.
+ */
+export function toGrpcSendInput(args) {
+    const preferences = args.preferences ?? DEFAULT_PREFERENCES;
+    const request = args.request;
+    const api = args.apiSettings ?? {};
+    const defaultMetadata = {};
+    if (preferences.http.userAgent.length > 0) {
+        defaultMetadata['user-agent'] = preferences.http.userAgent;
+    }
+    const timeoutMs = inherited(request.settings.timeoutMs, api.timeoutMs, args.projectSettings?.defaultTimeoutMs) ??
+        preferences.http.socketTimeoutMs;
+    const maxSizeBytes = inherited(request.settings.maxSizeBytes, api.maxSizeBytes);
+    const bindAddress = inherited(request.settings.bindAddress, api.bindAddress);
+    return {
+        target: args.target,
+        tls: args.tls,
+        service: request.service,
+        method: request.method,
+        metadata: [...(args.apiMetadata ?? []), ...request.metadata],
+        defaultMetadata,
+        timeoutMs,
+        ...(maxSizeBytes !== undefined ? { maxSizeBytes } : {}),
+        ...(bindAddress !== undefined && bindAddress.length > 0 ? { localAddress: bindAddress } : {}),
+        ...(args.auth !== undefined ? { auth: args.auth } : {}),
+        tlsOptions: { minVersion: preferences.ssl.minVersion, ...args.tlsOptions },
+        ...(args.signal !== undefined ? { signal: args.signal } : {}),
+    };
+}

package/dist/grpc/send.d.ts

@@ -14,8 +14,8 @@
  */
 import type { SslInfo } from '../http/tls.js';
 import type { Timings, TlsOptions } from '../http/types.js';
-import type { KeyValueEntry } from '../rest/model.js';
-import type { SendAuth } from '../types.js';
+import type { KeyValueEntry } from '../http/entries.js';
+import type { SendAuth } from '../http/auth/send-auth.js';
 import type { GrpcTarget } from './target.js';
 export { parseGrpcTarget } from './target.js';
 export type { GrpcTarget } from './target.js';

package/dist/grpc/status.d.ts

@@ -2,10 +2,17 @@
  * 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>>;
+import type { StatusNames } from '../assert/model.js';
+import { GRPC_STATUS_NAMES } from '../assert/status-names.js';
+export { GRPC_STATUS_NAMES };
 /** The name of a status code, or `UNKNOWN (n)` for a number the specification does not define. */
 export declare function grpcStatusName(code: number): string;
+/**
+ * The status codes by name and back, as a gRPC answer's assertion subject carries them (spec §3.5).
+ *
+ * @internal Exported for the engine's own hosts; not yet a plugin API (ADR-0017).
+ */
+export declare const grpcStatusNames: StatusNames;
 /**
  * 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

package/dist/grpc/status.js

@@ -1,31 +1,18 @@
-/**
- * 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',
-});
+import { GRPC_STATUS_NAMES } from '../assert/status-names.js';
+export { GRPC_STATUS_NAMES };
 /** 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)})`;
 }
+/**
+ * The status codes by name and back, as a gRPC answer's assertion subject carries them (spec §3.5).
+ *
+ * @internal Exported for the engine's own hosts; not yet a plugin API (ADR-0017).
+ */
+export const grpcStatusNames = Object.freeze({
+    byName: new Map(Object.entries(GRPC_STATUS_NAMES).map(([code, name]) => [name, Number(code)])),
+    nameOf: grpcStatusName,
+});
 /**
  * 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

package/dist/grpc/storage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * How gRPC APIs are stored in a project folder (spec §3.2): `apis/<slug>/api.yaml` with
+ * `kind: grpc`, and a tree of folders and `*.request.yaml` files under `requests/`, each request's
+ * message in the sibling `<slug>.body.json`.
+ */
+import type { ProtocolStorage } from '../protocol/module.js';
+import type { GrpcApi } from './model.js';
+/** gRPC's storage facet. */
+export declare const grpcStorage: ProtocolStorage<GrpcApi>;

package/dist/grpc/storage.js

@@ -0,0 +1,167 @@
+/**
+ * How gRPC APIs are stored in a project folder (spec §3.2): `apis/<slug>/api.yaml` with
+ * `kind: grpc`, and a tree of folders and `*.request.yaml` files under `requests/`, each request's
+ * message in the sibling `<slug>.body.json`.
+ */
+import { toCallbackAssertion } from '../assert/schema.js';
+import { readFileIfExists } from '../project/fs.js';
+import { abs, authConfig, exact, keyValueEntries, loadFolderContents, loadScripts, optional, readYaml, } from '../project/load-helpers.js';
+import { apiManagedFiles } from '../project/managed-files.js';
+import { API_FILE, APIS_DIR, assertPathSegment, REQUEST_SUFFIX, REQUESTS_DIR, restBodyFileName, } from '../project/paths.js';
+import { assertSupportedKind, parseFile } from '../project/schema-parts.js';
+import { addFolderFiles, authDocument, keyValueDocuments, scriptsDocument, writeScriptFiles, } from '../project/serialize-helpers.js';
+import { compact, stringifyYaml } from '../project/yaml.js';
+import { grpcApiFileSchema, grpcRequestFileSchema } from './files.js';
+/**
+ * Reads a gRPC request and its message file. A request whose message file is gone loads with an
+ * empty message and a `missing-body` problem, exactly as a REST raw body does.
+ */
+function grpcRequestReader(fs, root, problems) {
+    return async (dir, fileName, unclaimed) => {
+        const relative = `${dir}/${fileName}`;
+        const document = await readYaml(fs, root, relative);
+        assertSupportedKind(document, relative);
+        const parsed = parseFile(grpcRequestFileSchema, document, relative);
+        unclaimed.delete(fileName);
+        let message = '';
+        if (parsed.message !== undefined) {
+            // As a REST body file: a name beside the request, never a path out of it.
+            assertPathSegment(parsed.message);
+            unclaimed.delete(parsed.message);
+            const messageRelative = `${dir}/${parsed.message}`;
+            const text = await readFileIfExists(fs, abs(root, messageRelative));
+            if (text === undefined) {
+                problems.push({
+                    code: 'missing-body',
+                    message: `Request "${parsed.name}" has no message file; loaded with an empty message`,
+                    file: messageRelative,
+                });
+            }
+            else {
+                message = text.toString('utf8');
+            }
+        }
+        const scripts = await loadScripts(fs, root, dir, fileName.slice(0, -REQUEST_SUFFIX.length), parsed.scripts, parsed.name, problems, (name) => unclaimed.delete(name));
+        return {
+            kind: 'grpc',
+            id: parsed.id,
+            name: parsed.name,
+            slug: fileName.slice(0, -REQUEST_SUFFIX.length),
+            order: parsed.order,
+            ...optional('description', parsed.description),
+            service: parsed.service,
+            method: parsed.method,
+            methodKind: parsed.methodKind,
+            metadata: keyValueEntries(parsed.metadata),
+            message,
+            auth: authConfig(parsed.auth),
+            settings: exact(parsed.settings),
+            ...(parsed.orphaned === true ? { orphaned: true } : {}),
+            ...(parsed.assertions.length > 0
+                ? {
+                    assertions: parsed.assertions.map((a) => a.type === 'callback' ? toCallbackAssertion(a) : exact(a)),
+                }
+                : {}),
+            ...(scripts !== undefined ? { scripts } : {}),
+        };
+    };
+}
+/**
+ * A gRPC request as written: the message text goes to `<slug>.body.json` beside the document, the
+ * same convention as a REST raw body, so a message is a JSON file in git.
+ */
+const writeGrpcRequest = (files, dir, request) => {
+    const messageFile = restBodyFileName(request.slug, 'json');
+    assertPathSegment(messageFile);
+    files.set(`${dir}/${request.slug}${REQUEST_SUFFIX}`, stringifyYaml(compact({
+        kind: request.kind,
+        id: request.id,
+        name: request.name,
+        order: request.order,
+        description: request.description,
+        service: request.service,
+        method: request.method,
+        methodKind: request.methodKind,
+        metadata: request.metadata.length > 0 ? keyValueDocuments(request.metadata) : undefined,
+        message: messageFile,
+        auth: authDocument(request.auth),
+        settings: Object.keys(request.settings).length > 0 ? compact({ ...request.settings }) : undefined,
+        orphaned: request.orphaned === true ? true : undefined,
+        assertions: request.assertions !== undefined && request.assertions.length > 0
+            ? request.assertions.map((a) => compact({ ...a }))
+            : undefined,
+        scripts: scriptsDocument(request.scripts, request.slug).document,
+    })));
+    files.set(`${dir}/${messageFile}`, request.message);
+    writeScriptFiles(files, dir, request.scripts, request.slug);
+};
+/** Every file one gRPC API occupies. It shares `apis/` with the REST ones; its `kind` says which it is. */
+function addGrpcApiFiles(files, api) {
+    assertPathSegment(api.slug);
+    const base = `${APIS_DIR}/${api.slug}`;
+    files.set(`${base}/${API_FILE}`, stringifyYaml(compact({
+        kind: api.kind,
+        id: api.id,
+        name: api.name,
+        order: api.order,
+        description: api.description,
+        target: api.target,
+        tls: api.tls,
+        metadata: api.metadata.length > 0 ? keyValueDocuments(api.metadata) : undefined,
+        auth: api.auth === undefined ? undefined : authDocument(api.auth),
+        definition: api.definition === undefined
+            ? undefined
+            : compact({
+                kind: api.definition.kind,
+                source: api.definition.source,
+                cache: api.definition.cache,
+                roots: [...api.definition.roots],
+                reflectionVersion: api.definition.reflectionVersion,
+                trustInvalid: api.definition.trustInvalid,
+            }),
+    })));
+    addFolderFiles(files, `${base}/${REQUESTS_DIR}`, api, 0, writeGrpcRequest);
+}
+/** gRPC's storage facet. */
+export const grpcStorage = {
+    dir: APIS_DIR,
+    async load(ctx, slug, document) {
+        const { fs, root, problems } = ctx;
+        const parsed = parseFile(grpcApiFileSchema, document, `${APIS_DIR}/${slug}/${API_FILE}`);
+        const contents = await loadFolderContents(fs, root, `${APIS_DIR}/${slug}/${REQUESTS_DIR}`, 0, problems, grpcRequestReader(fs, root, problems));
+        return {
+            kind: 'grpc',
+            id: parsed.id,
+            name: parsed.name,
+            slug,
+            order: parsed.order,
+            ...optional('description', parsed.description),
+            target: parsed.target,
+            tls: parsed.tls,
+            metadata: keyValueEntries(parsed.metadata),
+            ...(parsed.auth !== undefined ? { auth: authConfig(parsed.auth) } : {}),
+            ...(parsed.definition !== undefined
+                ? {
+                    definition: {
+                        kind: parsed.definition.kind,
+                        source: parsed.definition.source,
+                        cache: parsed.definition.cache,
+                        roots: parsed.definition.roots,
+                        ...optional('reflectionVersion', parsed.definition.reflectionVersion),
+                        ...optional('trustInvalid', parsed.definition.trustInvalid),
+                    },
+                }
+                : {}),
+            folders: contents.folders,
+            requests: contents.requests,
+        };
+    },
+    files(api) {
+        const files = new Map();
+        addGrpcApiFiles(files, api);
+        return files;
+    },
+    managed: (fs, root, slug) => apiManagedFiles(fs, root, slug),
+    containers: (project) => project.grpcApis,
+    withContainers: (project, grpcApis) => ({ ...project, grpcApis }),
+};