@trevrpc/trevrpc-js 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 trev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# trevrpc-js
+
+`trevrpc-js` is the ESM-only JavaScript runtime and protobuf.js generator for TrevRPC.
+
+## Generated files
+
+For every protobuf file containing services, `protoc-gen-trevrpc-js` emits an ordinary browser-safe client module and a separate Node server module:
+
+```text
+greeter.trevrpc.js
+greeter.trevrpc.d.ts
+greeter.node.trevrpc.js
+greeter.node.trevrpc.d.ts
+```
+
+The ordinary module contains the protobuf root, service descriptors, typed clients, and client factories. The Node companion contains typed handler interfaces and registration helpers backed by `@trevrpc/trevrpc-js/node/generated`.
+
+```sh
+protoc \
+  --plugin=protoc-gen-trevrpc-js=./node_modules/.bin/protoc-gen-trevrpc-js \
+  --trevrpc-js_out=. \
+  greeter.proto
+```
+
+Generator options are `runtime_import`, `runtime_type_import`, `node_runtime_import`, `node_runtime_type_import`, and `file_suffix`. Runtime type imports default to their matching runtime import for bare and relative specifiers. URL specifiers such as `file:` require an explicit type import because TypeScript NodeNext does not resolve them in declarations. A Node import is never inferred by appending `/node` to another specifier.
+
+## Browser clients
+
+Browser declarations accept only `BrowserChannelOptions`.
+
+```js
+import { connect } from "@trevrpc/trevrpc-js";
+import { GreeterClient } from "./greeter.trevrpc.js";
+
+const channel = await connect("https://localhost:50051/trevrpc", {
+  timeoutMs: 10_000,
+  congestionControl: "low-latency",
+  serverCertificateHashes: [{ algorithm: "sha-256", value: certificateHash }],
+});
+try {
+  const client = new GreeterClient(channel, { timeoutMs: 5_000 });
+  const reply = await client.sayHello({ name: "TrevRPC" });
+  console.log(reply.message);
+} finally {
+  channel.close({ closeCode: 0, reason: "client shutdown" });
+}
+```
+
+Native TLS bypass, certificate validation, MsQuic buffering, and native stream options are intentionally unavailable under browser or Bundler resolution.
+
+## Node clients
+
+Under Node conditions, the root package uses the native channel. The explicit `@trevrpc/trevrpc-js/node` subpath also exports `Channel`, `NodeServer`, and `NodeServerCall`.
+
+```js
+import { connect } from "@trevrpc/trevrpc-js";
+import { GreeterClient } from "./greeter.trevrpc.js";
+
+const channel = await connect("https://localhost:50051", {
+  timeoutMs: 10_000,
+  caCertFile: "localhost-cert.pem",
+});
+try {
+  console.log(channel.endpoint); // frozen { host, port }
+  console.log(channel.options); // frozen effective NodeChannelOptions
+  const client = new GreeterClient(channel, { timeoutMs: 5_000 });
+  console.log((await client.sayHello({ name: "TrevRPC" })).message);
+} finally {
+  channel.close();
+}
+```
+
+URL and `{ host, port, ...options }` forms normalize to the same public state. Channels reconnect for future calls after native transport loss, but never replay or resume an operation that already failed.
+
+## Streaming clients
+
+Server-streaming methods resolve to `ResponseAsyncIterable<T>`:
+
+```js
+const replies = await client.lotsOfReplies({ name: "TrevRPC" });
+try {
+  for await (const reply of replies) {
+    console.log(reply.message);
+  }
+  const terminal = await replies.status;
+  console.log(terminal.code, terminal.message, terminal.metadata);
+} finally {
+  await replies.close();
+}
+```
+
+Full clean consumption resolves `status`. A non-OK terminal status rejects iteration and `status` with the same `TrevRpcError`. `close()`, iterator `return()`, and breaking a `for await` loop cancel the stream and reject `status` with `Code.Cancelled`. Consuming a valid terminal frame claims terminal precedence and cancels the absolute deadline, but `status` settles only after trailing EOF is validated; merely buffering a status frame is not completion.
+
+The status/error text distinction is deliberate:
+
+- `StreamStatus.message` is the unmodified peer terminal message.
+- `TrevRpcError.statusMessage` is the unmodified peer error message.
+- `TrevRpcError.message` is formatted JavaScript text such as `"Unavailable: down"`.
+
+Unary and client-streaming terminal metadata is available through `sayHelloWithResponse()` and `closeAndRecvWithResponse()`.
+
+Client streaming:
+
+```js
+const call = await client.lotsOfGreetings();
+await call.send({ name: "Alice" });
+await call.send({ name: "Bob" });
+const { message, metadata } = await call.closeAndRecvWithResponse();
+```
+
+Bidirectional streaming:
+
+```js
+const call = await client.bidiHello();
+try {
+  await call.send({ name: "Alice" });
+  console.log(await call.recv());
+  await call.closeSend();
+  while ((await call.recv()) != null) {}
+  console.log(await call.status);
+} finally {
+  await call.close();
+}
+```
+
+`timeoutMs` is one absolute RPC deadline that begins before transport setup and covers upload, send, receive, and cleanup. The same `DeadlineExceeded` object wins signal and rejection settlement. `streamIdleTimeoutMs` remains an independent per-read inactivity bound.
+
+## Typed Node servers
+
+Import the generated registration helper from the Node companion. Direct protobuf responses are never confused with metadata envelopes, even when they have `message` or `messages` properties.
+
+```js
+import { Code, createStreamingResponse, createUnaryResponse } from "@trevrpc/trevrpc-js";
+import { NodeServer } from "@trevrpc/trevrpc-js/node";
+import { registerGreeterServer } from "./greeter.node.trevrpc.js";
+
+const server = await NodeServer.listen({
+  host: "127.0.0.1",
+  port: 50051,
+  certFile: "localhost-cert.pem",
+  keyFile: "localhost-key.pem",
+});
+
+registerGreeterServer(server, {
+  sayHello(request, call) {
+    console.log(call.deadline, call.signal.aborted);
+    return createUnaryResponse(
+      { message: `Hello, ${request.name || "world"}` },
+      { trailer: "unary" },
+    );
+  },
+
+  async lotsOfGreetings(requests) {
+    const names = [];
+    for await (const request of requests) names.push(request.name);
+    return createUnaryResponse({ message: names.join(", ") }, { trailer: "client-stream" });
+  },
+
+  lotsOfReplies(request) {
+    return createStreamingResponse([{ message: request.name }], {
+      code: Code.Ok,
+      message: "complete",
+      metadata: { trailer: "server-stream" },
+    });
+  },
+
+  async *bidiHello(requests) {
+    for await (const request of requests) yield { message: request.name };
+  },
+});
+
+await server.serve();
+```
+
+Client-streaming completion uses streaming wire semantics: exactly one response message followed by exactly one terminal status; it never uses unary `respond()`.
+
+`NodeServerCall.signal` covers effective deadlines, server shutdown, local close, and cancellation observed by native I/O. The current native bridge cannot promptly report remote peer cancellation while a handler is idle and performs no call I/O; cancellation becomes observable when the handler next enters native call I/O.
+
+## Native package support
+
+The core tarball is platform-neutral. Native code is supplied by the exact optional package `@trevrpc/trevrpc-js-native-linux-x64-gnu@0.1.0`.
+
+Initial support is Linux x86-64, glibc 2.42 or newer, and Node 24. Browser usage still installs and runs on Darwin, ARM, and musl. Requesting a native Node channel on an unsupported or incomplete installation throws `TrevRpcError(Code.Unavailable)` with the detected target, supported targets, expected optional package, whether loading was missing or failed, and the original loader error as `cause`.
+
+All addon errors crossing public Node transport and server boundaries become `TrevRpcError` unless already normalized. `nativeCode` and `cause` preserve native provenance.
+
+## Package resolution
+
+Conditional ESM exports are authoritative; the package has no legacy top-level `main` or `types`. Use TypeScript NodeNext resolution for Node consumers and Bundler resolution with browser conditions for browser consumers.
+
+## Native development
+
+Installation never builds native code. In a source checkout:
+
+```sh
+npm run build:native:test
+npm test
+npm run build:native
+npm run verify:native:production
+```
+
+The development fallback is only `build/native/trevrpc_native.node` in a source checkout.

package/bin/protoc-gen-trevrpc-js.js

@@ -0,0 +1,17 @@
+#!/nix/store/zvj0hl7rhh0ccr5vkcg3ijs3xm3sgyac-nodejs-24.16.0/bin/node
+
+import { runGenerator } from "../src/generator.js";
+
+const chunks = [];
+
+for await (const chunk of process.stdin) {
+  chunks.push(chunk);
+}
+
+try {
+  const output = runGenerator(Buffer.concat(chunks));
+  process.stdout.write(output);
+} catch (error) {
+  console.error(`protoc-gen-trevrpc-js: ${error.message}`);
+  process.exit(1);
+}

package/examples/greeter/README.md

@@ -0,0 +1,35 @@
+# Greeter example
+
+This directory contains the generated Milestone 6 split:
+
+- `greeter.trevrpc.js` and `.d.ts`: protobuf root, descriptors, typed clients, and factories; browser-safe.
+- `greeter.node.trevrpc.js` and `.d.ts`: typed Node handler interfaces and `registerGreeterServer`.
+
+Browser code must import only `greeter.trevrpc.js`. Node servers import registration from `greeter.node.trevrpc.js` and use `createUnaryResponse` or `createStreamingResponse` when returning metadata or a custom terminal status. A direct protobuf object such as `{ message: "hello" }` remains a protobuf response.
+
+## Run the browser page
+
+From `trevrpc-js`:
+
+```sh
+npm run example:greeter
+```
+
+Open `http://127.0.0.1:8080/examples/greeter/` and use a WebTransport greeter endpoint:
+
+```text
+https://127.0.0.1:50051/trevrpc  # Go default
+https://127.0.0.1:5000/trevrpc   # Rust default
+```
+
+The path selects the WebTransport session; TrevRPC routing remains inside the request frame. The example policies allow origin `http://127.0.0.1:8080` and use bearer token `trevrpc-example-token`.
+
+Both example servers write their development certificate to `~/.config/trevrpc/trevrpc-example-cert.pem`. Override it with `TREVRPC_EXAMPLE_CERT`. The static server computes the SHA-256 DER hash and the browser client passes it through `serverCertificateHashes`.
+
+For a temporary self-signed certificate, calculate the hash with:
+
+```sh
+openssl x509 -in server.pem -outform der | openssl dgst -sha256 -binary | openssl base64
+```
+
+The client fully consumes server streams, then reads terminal metadata from `stream.status`. It calls `close()` when abandoning streams. Client `timeoutMs` is absolute across setup, upload, and receive, while `streamIdleTimeoutMs` is a separate inactivity bound.

package/examples/greeter/client.js

@@ -0,0 +1,172 @@
+import { TrevRpcError, connect } from "../../src/index.js";
+import { GreeterClient } from "./greeter.trevrpc.js";
+
+const form = document.querySelector("#client-form");
+const output = document.querySelector("#output");
+const submit = document.querySelector("#submit");
+
+void loadExampleDefaults();
+
+form.addEventListener("submit", (event) => {
+  event.preventDefault();
+  void runFromForm(new FormData(form));
+});
+
+for (const preset of document.querySelectorAll("[data-url]")) {
+  preset.addEventListener("click", () => {
+    form.elements.url.value = preset.dataset.url;
+  });
+}
+
+async function runFromForm(data) {
+  output.textContent = "";
+  submit.disabled = true;
+
+  const url = String(data.get("url") ?? "").trim();
+  const name = String(data.get("name") ?? "TrevRPC").trim() || "TrevRPC";
+  const token = String(data.get("token") ?? "").trim();
+  const certificateHash = String(data.get("certificate-hash") ?? "").trim();
+
+  let channel;
+  try {
+    log(`connecting to ${url}`);
+    channel = await connect(url, {
+      ...browserConnectOptions(certificateHash),
+      timeoutMs: 10_000,
+    });
+    const client = new GreeterClient(channel, {
+      timeoutMs: 5_000,
+      metadata: token === "" ? {} : { authorization: `Bearer ${token}` },
+    });
+
+    const unary = await client.sayHello({ name });
+    log(`SayHello: ${unary.message}`);
+
+    const replies = await client.lotsOfReplies({ name });
+    for await (const reply of replies) {
+      log(`LotsOfReplies: ${reply.message}`);
+    }
+    const replyStatus = await replies.status;
+    log(
+      `LotsOfReplies status: ${replyStatus.code} ${replyStatus.message}; trailers=${Object.keys(replyStatus.metadata).join(",")}`,
+    );
+
+    const greetings = await client.lotsOfGreetings();
+    await greetings.send({ name: `${name} client stream 1` });
+    await greetings.send({ name: `${name} client stream 2` });
+    const summary = await greetings.closeAndRecvWithResponse();
+    log(
+      `LotsOfGreetings: ${summary.message.message}; trailers=${Object.keys(summary.metadata).join(",")}`,
+    );
+
+    const bidi = await client.bidiHello();
+    try {
+      for (const suffix of ["bidi 1", "bidi 2"]) {
+        await bidi.send({ name: `${name} ${suffix}` });
+
+        const reply = await bidi.recv();
+        if (reply == null) {
+          throw new Error("BidiHello response stream ended early");
+        }
+        log(`BidiHello: ${reply.message}`);
+      }
+      await bidi.closeSend();
+
+      for (;;) {
+        const reply = await bidi.recv();
+        if (reply == null) {
+          break;
+        }
+        log(`BidiHello: ${reply.message}`);
+      }
+    } finally {
+      await bidi.close();
+    }
+
+    log("complete");
+  } catch (error) {
+    logError(error);
+  } finally {
+    submit.disabled = false;
+    channel?.close({ closeCode: 0, reason: "example complete" });
+  }
+}
+
+function browserConnectOptions(certificateHash) {
+  if (certificateHash === "") {
+    return {};
+  }
+
+  return {
+    serverCertificateHashes: [
+      {
+        algorithm: "sha-256",
+        value: parseSha256Hash(certificateHash),
+      },
+    ],
+  };
+}
+
+async function loadExampleDefaults() {
+  try {
+    const response = await fetch("./certificate-hash.json", { cache: "no-store" });
+    if (!response.ok) {
+      return;
+    }
+
+    const config = await response.json();
+    if (typeof config.bearerToken === "string" && form.elements.token.value === "") {
+      form.elements.token.value = config.bearerToken;
+    }
+    if (config.exists && typeof config.sha256Base64 === "string") {
+      form.elements["certificate-hash"].value = config.sha256Base64;
+      log(`loaded certificate hash from ${config.path}`);
+    } else if (typeof config.path === "string") {
+      log(`certificate not found at ${config.path}; start a Go or Rust example server first`);
+    }
+  } catch (error) {
+    log(`could not load local certificate hash: ${error?.message ?? String(error)}`);
+  }
+}
+
+function parseSha256Hash(value) {
+  const normalized = value
+    .trim()
+    .replace(/^sha-?256[=:]/i, "")
+    .trim();
+  const hex = normalized.replace(/[:\s]/g, "");
+
+  if (/^[0-9a-fA-F]{64}$/.test(hex)) {
+    const bytes = new Uint8Array(32);
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+  }
+
+  const base64 = normalized.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
+  const binary = atob(padded);
+  if (binary.length !== 32) {
+    throw new Error("certificate hash must decode to 32 bytes of SHA-256 data");
+  }
+
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+function log(message) {
+  output.textContent += `${message}\n`;
+}
+
+function logError(error) {
+  if (error instanceof TrevRpcError) {
+    log(`RPC error: ${error.code}: ${error.statusMessage || error.message}`);
+    return;
+  }
+
+  log(`error: ${error?.message ?? String(error)}`);
+}

package/examples/greeter/greeter.node.trevrpc.d.ts

@@ -0,0 +1,53 @@
+// Code generated by protoc-gen-trevrpc-js. DO NOT EDIT.
+
+import type {
+  NodeServer,
+  NodeServerCall,
+  StreamingServerResponse,
+  UnaryServerResponse,
+} from "../../src/node-generated.js";
+import type { HelloRequest, HelloReply } from "./greeter.trevrpc.js";
+
+/** Typed Node handlers for the Greeter service. */
+export interface GreeterHandlers {
+  sayHello?(
+    request: HelloRequest,
+    call: NodeServerCall,
+  ):
+    | HelloReply
+    | UnaryServerResponse<HelloReply>
+    | Promise<HelloReply | UnaryServerResponse<HelloReply>>;
+  lotsOfReplies?(
+    request: HelloRequest,
+    call: NodeServerCall,
+  ):
+    | Iterable<HelloReply>
+    | AsyncIterable<HelloReply>
+    | StreamingServerResponse<HelloReply>
+    | Promise<
+        Iterable<HelloReply> | AsyncIterable<HelloReply> | StreamingServerResponse<HelloReply>
+      >;
+  lotsOfGreetings?(
+    requests: AsyncIterable<HelloRequest>,
+    call: NodeServerCall,
+  ):
+    | HelloReply
+    | UnaryServerResponse<HelloReply>
+    | Promise<HelloReply | UnaryServerResponse<HelloReply>>;
+  bidiHello?(
+    requests: AsyncIterable<HelloRequest>,
+    call: NodeServerCall,
+  ):
+    | Iterable<HelloReply>
+    | AsyncIterable<HelloReply>
+    | StreamingServerResponse<HelloReply>
+    | Promise<
+        Iterable<HelloReply> | AsyncIterable<HelloReply> | StreamingServerResponse<HelloReply>
+      >;
+}
+
+/** Registers typed Node handlers for the Greeter service. */
+export declare function registerGreeterServer(
+  server: NodeServer,
+  handlers: GreeterHandlers,
+): NodeServer;

package/examples/greeter/greeter.node.trevrpc.js

@@ -0,0 +1,9 @@
+// Code generated by protoc-gen-trevrpc-js. DO NOT EDIT.
+
+import { registerTypedService } from "../../src/node-generated.js";
+import { GreeterService, root } from "./greeter.trevrpc.js";
+
+/** Registers typed Node handlers for the Greeter service. */
+export function registerGreeterServer(server, handlers) {
+  return registerTypedService(server, root, GreeterService, handlers);
+}

package/examples/greeter/greeter.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package example.greeter;
+
+service Greeter {
+  rpc SayHello(HelloRequest) returns (HelloReply);
+  rpc LotsOfReplies(HelloRequest) returns (stream HelloReply);
+  rpc LotsOfGreetings(stream HelloRequest) returns (HelloReply);
+  rpc BidiHello(stream HelloRequest) returns (stream HelloReply);
+}
+
+message HelloRequest {
+  string name = 1;
+}
+
+message HelloReply {
+  string message = 1;
+}

package/examples/greeter/greeter.trevrpc.d.ts

@@ -0,0 +1,55 @@
+// Code generated by protoc-gen-trevrpc-js. DO NOT EDIT.
+
+import type { Long, Root } from "protobufjs";
+
+import type {
+  BidirectionalStreamingCall,
+  CallOptions,
+  ClientStreamingCall,
+  ResponseAsyncIterable,
+  RpcServiceDescriptor,
+  Transport,
+  UnaryResponse,
+} from "../../src/index.js";
+
+export declare const root: Root;
+
+export interface HelloRequest {
+  name?: string;
+}
+
+export interface HelloReply {
+  message?: string;
+}
+
+/** Service descriptor for the Greeter service. */
+export declare const GreeterService: RpcServiceDescriptor;
+
+/** Client for the Greeter service. */
+export declare class GreeterClient {
+  /** Creates a client for the Greeter service. */
+  constructor(transport: Transport, options?: CallOptions);
+
+  /** Calls the SayHello RPC. */
+  sayHello(request: HelloRequest, options?: CallOptions): Promise<HelloReply>;
+  /** Calls the SayHello RPC and returns response metadata. */
+  sayHelloWithResponse(
+    request: HelloRequest,
+    options?: CallOptions,
+  ): Promise<UnaryResponse<HelloReply>>;
+  /** Calls the LotsOfReplies RPC. */
+  lotsOfReplies(
+    request: HelloRequest,
+    options?: CallOptions,
+  ): Promise<ResponseAsyncIterable<HelloReply>>;
+  /** Calls the LotsOfGreetings RPC. */
+  lotsOfGreetings(options?: CallOptions): Promise<ClientStreamingCall<HelloRequest, HelloReply>>;
+  /** Calls the BidiHello RPC. */
+  bidiHello(options?: CallOptions): Promise<BidirectionalStreamingCall<HelloRequest, HelloReply>>;
+}
+
+/** Creates a client for the Greeter service. */
+export declare function createGreeterClient(
+  transport: Transport,
+  options?: CallOptions,
+): GreeterClient;

package/examples/greeter/greeter.trevrpc.js

@@ -0,0 +1,103 @@
+// Code generated by protoc-gen-trevrpc-js. DO NOT EDIT.
+
+import { createRoot, createServiceClient } from "../../src/index.js";
+
+export const root = createRoot({
+  nested: {
+    example: {
+      nested: {
+        greeter: {
+          nested: {
+            HelloRequest: {
+              fields: {
+                name: {
+                  type: "string",
+                  id: 1,
+                },
+              },
+            },
+            HelloReply: {
+              fields: {
+                message: {
+                  type: "string",
+                  id: 1,
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+});
+
+/** Service descriptor for the Greeter service. */
+export const GreeterService = Object.freeze({
+  name: "Greeter",
+  fullName: "example.greeter.Greeter",
+  exportName: "GreeterService",
+  methods: {
+    sayHello: {
+      name: "SayHello",
+      kind: "unary",
+      inputType: "example.greeter.HelloRequest",
+      outputType: "example.greeter.HelloReply",
+    },
+    lotsOfReplies: {
+      name: "LotsOfReplies",
+      kind: "serverStreaming",
+      inputType: "example.greeter.HelloRequest",
+      outputType: "example.greeter.HelloReply",
+    },
+    lotsOfGreetings: {
+      name: "LotsOfGreetings",
+      kind: "clientStreaming",
+      inputType: "example.greeter.HelloRequest",
+      outputType: "example.greeter.HelloReply",
+    },
+    bidiHello: {
+      name: "BidiHello",
+      kind: "bidirectionalStreaming",
+      inputType: "example.greeter.HelloRequest",
+      outputType: "example.greeter.HelloReply",
+    },
+  },
+});
+
+/** Client for the Greeter service. */
+export class GreeterClient {
+  /** Creates a client for the Greeter service. */
+  constructor(transport, options = {}) {
+    this._client = createServiceClient(transport, GreeterService, root, options);
+  }
+
+  /** Calls the SayHello RPC. */
+  sayHello(request, options = {}) {
+    return this._client.sayHello(request, options);
+  }
+
+  /** Calls the SayHello RPC and returns response metadata. */
+  sayHelloWithResponse(request, options = {}) {
+    return this._client.sayHelloWithResponse(request, options);
+  }
+
+  /** Calls the LotsOfReplies RPC. */
+  lotsOfReplies(request, options = {}) {
+    return this._client.lotsOfReplies(request, options);
+  }
+
+  /** Calls the LotsOfGreetings RPC. */
+  lotsOfGreetings(options = {}) {
+    return this._client.lotsOfGreetings(options);
+  }
+
+  /** Calls the BidiHello RPC. */
+  bidiHello(options = {}) {
+    return this._client.bidiHello(options);
+  }
+}
+
+/** Creates a client for the Greeter service. */
+export function createGreeterClient(transport, options = {}) {
+  return new GreeterClient(transport, options);
+}