@trevrpc/trevrpc-js 1.4.0 → 1.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 TrevRPC is an RPC framework like gRPC, but uses QUIC (and HTTP/3 / WebTransport) instead of HTTP/2. Define services in protobuf, generate typed clients, and call Go or Rust servers over WebTransport, falling back to QMux over WebSocket where WebTransport is missing or UDP is blocked.
 
-`trevrpc-js` is the **browser client**: a WebTransport runtime with a QMux over WebSocket fallback, plus `protoc-gen-trevrpc-js`, which generates typed clients (no server code). It has no Node.js runtime; servers are written in Go or Rust, native QUIC clients in Go or Rust, and HTTP/3 clients in Kotlin.
+`trevrpc-js` is the **browser client**: a WebTransport runtime with a QMux over WebSocket fallback, for the messages and service descriptors that [protobuf-es](https://github.com/bufbuild/protobuf-es) generates. It has no Node.js runtime; servers are written in Go or Rust, native QUIC clients in Go or Rust, and HTTP/3 clients in Kotlin.
 
 Full documentation: https://trev.zip/llc/TrevRPC/wiki
 
@@ -24,61 +24,52 @@ message HelloRequest { string name = 1; }
 message HelloReply { string message = 1; }
 ```
 
-Generate a client with the protoc plugin (it needs Node.js to run):
+TrevRPC has no code generator of its own for JavaScript: generate the messages and the service descriptor with protobuf-es's `protoc-gen-es`, and pass the descriptor to `createClient()`.
 
 ```sh
-npm install @trevrpc/trevrpc-js
+npm install @trevrpc/trevrpc-js @bufbuild/protobuf
+npm install --save-dev @bufbuild/protoc-gen-es
 protoc \
-  --plugin=protoc-gen-trevrpc-js=node_modules/.bin/protoc-gen-trevrpc-js \
-  --trevrpc-js_out=src/gen \
+  --plugin=protoc-gen-es=node_modules/.bin/protoc-gen-es \
+  --es_out=src/gen --es_opt=target=ts \
   greeter.proto
 ```
 
-This writes `greeter.trevrpc.js` and `greeter.trevrpc.d.ts`. Plugin parameters (`--trevrpc-js_out=key=value,key=value:dir`):
+This writes `greeter_pb.ts` with `HelloRequestSchema`, `HelloReplySchema` and the `Greeter` service descriptor ([`buf generate`](https://buf.build/docs/generate/overview/) with the `buf.build/bufbuild/es` plugin works the same). `@bufbuild/protobuf` is a peer dependency, so the generated code and the client share one copy.
 
-| Parameter             | Default                  | Meaning                                                                              |
-| --------------------- | ------------------------ | ------------------------------------------------------------------------------------ |
-| `runtime_import`      | `@trevrpc/trevrpc-js`    | Module specifier the generated JavaScript imports.                                   |
-| `runtime_type_import` | same as `runtime_import` | Module specifier the declarations import; required when `runtime_import` is a URL.   |
-| `file_suffix`         | `.trevrpc.js`            | Suffix of the generated files.                                                       |
-| `int64`               | `bigint`                 | How decoded 64-bit integers are represented: `bigint`, `number`, `string` or `long`. |
+### Messages
 
-### Generated types
-
-The declarations cover the file's own messages and enums and every type they and its services use, including those of imported files. Each message has two shapes:
-
-- `Foo`, a decoded message, which calls return and streams yield. Every field reads a value: scalars and enums their default when unset, repeated fields and maps an empty array and object, and message and `optional` fields `null` when unset.
-- `FooInit`, a message to send, in which every field may be left out. Requests take it, and a decoded `Foo` can be sent as one.
-
-Each enum is exported as a frozen object of its values and as the type of those values. When every value starts with the enum's name in upper snake case, the prefix is dropped, as protobuf-es does: `TIME_INTERVAL_HOUR` of `TimeInterval` is `TimeInterval.HOUR`.
+Messages are protobuf-es messages; see its [manual](https://github.com/bufbuild/protobuf-es/blob/main/MANUAL.md) for the details. Requests take a message or the init object `create()` takes, in which every field may be left out; calls return and streams yield messages, in which scalars, repeated fields and maps always have a value and message fields are `undefined` when unset. Oneofs are `{ case, value }`, 64-bit integers are `bigint` (or `string` with `[jstype = JS_STRING]`), `google.protobuf.Struct` is a JSON object, and `@bufbuild/protobuf/wkt` has helpers for the well-known types, such as `timestampFromDate` and `timestampDate`.
 
 ```ts
-import { TimeInterval, type Sample } from "./gen/metrics.trevrpc.js";
+import { timestampDate, timestampFromDate } from "@bufbuild/protobuf/wkt";
 
-const sample: Sample = await client.get({ interval: TimeInterval.HOUR });
+import { Metrics, TimeInterval } from "./gen/metrics_pb.js";
+
+const metrics = createClient(Metrics, channel);
+const sample = await metrics.get({
+  interval: TimeInterval.HOUR,
+  at: timestampFromDate(new Date()),
+});
 sample.count; // bigint, never undefined
+const at = sample.at && timestampDate(sample.at);
 ```
 
-64-bit integers decode as `bigint` by default; requests take a `bigint`, a `number` or a decimal `string`. The `int64` plugin option picks `number` (exact up to 2^53), `string`, or `long` (protobuf.js `Long` objects, without the conversion) instead, and a field's `jstype` option (`[jstype = JS_STRING]` or `JS_NUMBER`) overrides it for that field. 64-bit map keys are decimal strings. `JSON.stringify` throws on a `bigint`, so a decoded message with a 64-bit field needs a replacer to serialize, such as `(key, value) => (typeof value === "bigint" ? value.toString() : value)`, or generate with `int64=string`.
+`JSON.stringify` throws on a `bigint`; use protobuf-es's `toJson()` or `toJsonString()` to serialize a message.
 
-`google.protobuf.Timestamp`, `Duration`, `Empty`, `Struct`, `Value`, `ListValue` and `NullValue` are declared once by the runtime, which generated files import (Timestamp and Duration only with `bigint`, since the runtime declares their seconds as one). The runtime has helpers for them: `timestampFromDate`, `timestampFromMs`, `timestampDate`, `timestampMs`, `durationFromMs`, `durationMs`, `structFromJson`, `structToJson`, `valueFromJson` and `valueToJson`. The Timestamp and Duration readers take seconds in any representation.
+### Method options
 
-```ts
-import { timestampDate, timestampFromDate } from "@trevrpc/trevrpc-js";
-
-await client.put({ at: timestampFromDate(new Date()) });
-const at = sample.at === null ? undefined : timestampDate(sample.at);
-```
+`createClient()` reads the `trevrpc.method` option of each method (from [`trevrpc/options.proto`](https://trev.zip/llc/TrevRPC/wiki/Getting-Started#schema-options)) from the descriptor, which protoc-gen-es keeps: `unreliable_requests` and `unreliable_responses` mark directions whose messages may travel as WebTransport datagrams ([Datagram Messages](https://trev.zip/llc/TrevRPC/wiki/Protocol-and-Wire-Format#datagram-messages)), and `compression` lets messages be compressed without a dictionary or a stream be compressed ([Compression](#compression)). An option the method's kind cannot use, such as `unreliable_requests` on a unary method or `COMPRESSION_STREAM` on one that streams nothing, makes `createClient()` throw `InvalidArgument`. Message types with a field marked `debug_redact` are never compressed that way.
 
 ## Client
 
 ```js
-import { connect } from "@trevrpc/trevrpc-js";
+import { connect, createClient } from "@trevrpc/trevrpc-js";
 
-import { GreeterClient } from "./gen/greeter.trevrpc.js";
+import { Greeter } from "./gen/greeter_pb.js";
 
 const channel = await connect("https://example.com:4433/trevrpc");
-const client = new GreeterClient(channel, { timeoutMs: 5_000 });
+const client = createClient(Greeter, channel, { timeoutMs: 5_000 });
 
 // Unary
 const reply = await client.sayHello({ name: "TrevRPC" });
@@ -110,7 +101,7 @@ channel.close();
 
 ### Call options
 
-Every method takes `CallOptions` as its last argument; the same options can be given to the client constructor as defaults, and per-call `metadata` is merged over the defaults per key. The constructor also takes `interceptors` ([below](#interceptors)).
+A client has one function per method, named by the method's `localName` (`SayHello` is `sayHello`). Every method takes `CallOptions` as its last argument; the same options can be given to `createClient()` as defaults, and per-call `metadata` is merged over the defaults per key. `createClient()` also takes `interceptors` ([below](#interceptors)).
 
 | Option               | Meaning                                                                                       |
 | -------------------- | --------------------------------------------------------------------------------------------- |
@@ -142,11 +133,53 @@ call.
 
 - To find the final status while the caller only sends, a client-streaming or bidirectional call reads the response ahead of `recv()` while its request side is open: at most 32 frames or 1 MiB (plus one frame of at most `maxFrameSize`) are held; beyond that reading pauses and flow control applies until `recv()` takes messages. Responses read ahead are delivered in order, including before an error that ended the stream.
 
+### Rendering long streams
+
+Once response messages are buffered, `for await` hands them over without returning to the event loop: each `next()` resolves as a microtask, as with any async iterator over a `fetch` body. When the network delivers faster than the page consumes, which is always the case on localhost, a loop over a long stream runs to its end before the browser renders anything, timers fire, or input is handled. The client does not yield on its own, because a timer-based yield would slow streams in hidden tabs and add latency for consumers that do not render.
+
+A page that renders a stream should batch messages per animation frame and, after a time budget, yield with a timer so that frame can render:
+
+```js
+let batch = [];
+let frame;
+const flush = () => {
+  frame = undefined;
+  store.append(batch);
+  batch = [];
+};
+
+let sliceStart = performance.now();
+try {
+  for await (const row of stream) {
+    batch.push(row);
+    frame ??= requestAnimationFrame(flush);
+    if (performance.now() - sliceStart > 8) {
+      if (document.hidden) {
+        cancelAnimationFrame(frame);
+        flush();
+      } else {
+        await new Promise((resolve) => setTimeout(resolve));
+      }
+      sliceStart = performance.now();
+    }
+  }
+} finally {
+  if (frame !== undefined) {
+    cancelAnimationFrame(frame);
+    flush();
+  }
+}
+```
+
+- `scheduler.yield()` does not help: Chromium resumes its continuation before rendering, so every message still lands in one frame.
+- Hidden tabs run no animation frames and throttle timers to about one per second, so while `document.hidden` the loop applies the batch itself after each time budget instead of yielding. It holds at most one budget's worth of messages, and a stream in a background tab keeps its speed.
+- If the stream fails or the loop is left early, which cancels the call, the `finally` still applies the messages received before.
+
 ### Connections
 
 `connect()` opens a session and resolves when it is ready; it rejects if no transport can establish one. After that the `Channel` re-establishes the session in the background with exponential backoff whenever it is lost. Calls fail fast with `Unavailable` while `channel.state` is `"reconnecting"` and are never replayed; use `await channel.waitUntilReady()` or the `onStateChange` option to follow the state. `channel.close()` stops reconnecting.
 
-`createChannel(url, options)` takes the same options but returns the channel right away, in the `"connecting"` state, so generated clients can be created before it is connected. Calls started while it connects wait for that first attempt, within their own deadline and signal; if it fails they fail with its error, and the channel goes on reconnecting with backoff like after a lost session. The `signal` option does not apply to it; close the channel to give up.
+`createChannel(url, options)` takes the same options but returns the channel right away, in the `"connecting"` state, so clients can be created before it is connected. Calls started while it connects wait for that first attempt, within their own deadline and signal; if it fails they fail with its error, and the channel goes on reconnecting with backoff like after a lost session. The `signal` option does not apply to it; close the channel to give up.
 
 ```js
 const channel = await connect(url, {
@@ -160,7 +193,7 @@ const channel = await connect(url, {
 
 `connect()` always offers the WebTransport protocol `trevrpc-1` (wire version 1) through the `protocols` constructor option; it cannot be changed. If the server selects any other protocol, that connection attempt fails with `Code.FailedPrecondition` and the channel carries on as after any failed dial: the WebSocket fallback starts, or a reconnect is retried with backoff. An empty or missing selection means version 1, because older browsers cannot negotiate protocols.
 
-Any object with `createBidirectionalStream()`, including a plain `WebTransport` session, can be used as the transport of a generated client. A transport that wraps a `Channel` should forward its `createBidirectionalStreamWithSession()`, `compression`, `connectionMetadata`, `streamCompressionBudget` and `interceptors`; without them its calls carry no connection metadata, get a stream compression budget of their own, and skip the channel's interceptors. Create such a session with `new WebTransport(url, { protocols: ["trevrpc-1"] })` so the server knows the wire version. Requests name the method by its full path, `/<package.Service>/<Method>` (for example `/example.greeter.Greeter/SayHello`), which the generated clients build from the service and method names.
+Any object with `createBidirectionalStream()`, including a plain `WebTransport` session, can be used as the transport of a client. A transport that wraps a `Channel` should forward its `createBidirectionalStreamWithSession()`, `compression`, `connectionMetadata`, `streamCompressionBudget` and `interceptors`; without them its calls carry no connection metadata, get a stream compression budget of their own, and skip the channel's interceptors. Create such a session with `new WebTransport(url, { protocols: ["trevrpc-1"] })` so the server knows the wire version. Requests name the method by its full path, `/<package.Service>/<Method>` (for example `/example.greeter.Greeter/SayHello`), which clients build from the service and method names.
 
 ### Connection metadata
 
@@ -194,7 +227,7 @@ const channel = createChannel(url, {
     },
   ],
 });
-const client = new GreeterClient(channel, { interceptors: [logCalls] });
+const client = createClient(Greeter, channel, { interceptors: [logCalls] });
 ```
 
 - An interceptor runs before the call starts, in order with the others, and may wait. It may add, replace and delete entries of `call.metadata`, which is validated after the last interceptor. The call's deadline starts after the interceptors; an interceptor that waits can watch `call.signal`.
@@ -202,6 +235,10 @@ const client = new GreeterClient(channel, { interceptors: [logCalls] });
 - An interceptor that throws fails the call with what it threw before it starts; the finish functions of earlier interceptors still run.
 - A client-streaming call has a `status` promise too, like the other streaming calls.
 
+### Effect
+
+The separate package [`@trevrpc/effect`](effect) makes clients for [Effect](https://effect.website): `createEffectClient(Greeter, channel)` returns a client whose unary calls are effects, whose server-streaming calls are streams, and whose client-streaming and bidirectional calls take their requests as a stream. Interrupting an effect or stream cancels its call. `TrevRpcError` has a `_tag` of `"TrevRpcError"`, so `Effect.catchTag` matches it.
+
 ### Compression
 
 Messages can travel compressed with zstd and a dictionary trained on them (see [Compression](https://trev.zip/llc/TrevRPC/wiki/Compression)). The codec lives in a separate entry point, `@trevrpc/trevrpc-js/zstd`, which loads libzstd as WebAssembly (about 85 KB gzipped), so applications without compression never load it:
@@ -238,7 +275,7 @@ console.log(channel.transport); // "webtransport" or "websocket"
 
 ## Interop client
 
-`trevrpc-interop-browser` runs the cross-runtime interop scenarios from [`interop/README.md`](../interop/README.md) in a real browser over WebTransport, QMux over WebSocket, or the fallback between them. It is built from `interop/proto/interop.proto` with the generator in this package, so it also serves as a complete example of generated client code.
+`trevrpc-interop-browser` runs the cross-runtime interop scenarios from [`interop/README.md`](../interop/README.md) in a real browser over WebTransport, QMux over WebSocket, or the fallback between them. It is built from `interop/proto/interop.proto` with protoc-gen-es, so it also serves as a complete example of a client.
 
 ```sh
 trevrpc-interop-browser --browser chromium|firefox|safari \
@@ -255,10 +292,10 @@ It prints `ok <name>` or `fail <name>: <reason>` per scenario and exits 0 only i
 ```sh
 npm ci
 npm run check      # format check, lint, typecheck, tests
-npm run build      # generate the interop clients and bundle the interop and benchmark pages into build/interop/
+npm run build      # generate the interop and test descriptors and bundle the interop and benchmark pages into build/interop/
 npm run interop -- --browser chromium --url ... --cert-hash ...
 ```
 
-`nix build .#trevrpc-js` runs the same checks and installs the library, the plugin and the wrapped `trevrpc-interop-browser` with matching Playwright browsers. The pinned `playwright` version must equal nixpkgs' `playwright-driver`; `nix run .#sync-playwright` updates it.
+`nix build .#trevrpc-js` runs the same checks and installs the library and the wrapped `trevrpc-interop-browser` with matching Playwright browsers. The pinned `playwright` version must equal nixpkgs' `playwright-driver`; `nix run .#sync-playwright` updates it.
 
-Tests (`node --test`) cover the wire format against `testdata/wire-golden-vectors.txt` (frame bytes, and the frame reader against the shared byte streams), the QMux frames against `testdata/qmux-golden-vectors.txt`, framing, the generator, and the client — deadlines, cancellation, stream termination and reconnection — against in-memory fake servers, including a fake Echo server that runs all interop scenarios.
+Tests (`node --test`) cover the wire format against `testdata/wire-golden-vectors.txt` (frame bytes, and the frame reader against the shared byte streams), the QMux frames against `testdata/qmux-golden-vectors.txt`, framing, the `trevrpc.method` option, and the client — deadlines, cancellation, stream termination and reconnection — against in-memory fake servers, including a fake Echo server that runs all interop scenarios.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trevrpc/trevrpc-js",
-  "version": "1.4.0",
-  "description": "Browser WebTransport client and protobuf.js code generator for TrevRPC",
+  "version": "1.6.0",
+  "description": "Browser WebTransport client for TrevRPC, on protobuf-es",
   "homepage": "https://trev.zip/llc/TrevRPC",
   "bugs": {
     "url": "https://trev.zip/llc/TrevRPC/issues"
@@ -11,12 +11,8 @@
     "type": "git",
     "url": "https://trev.zip/llc/TrevRPC.git"
   },
-  "bin": {
-    "protoc-gen-trevrpc-js": "bin/protoc-gen-trevrpc-js.js"
-  },
   "files": [
     "src/**",
-    "bin/protoc-gen-trevrpc-js.js",
     "README.md",
     "LICENSE"
   ],
@@ -46,20 +42,20 @@
     "check": "npm run format:check && npm run lint && npm run typecheck && npm test",
     "interop": "node interop-browser/cli.js"
   },
-  "dependencies": {
-    "protobufjs": "^8.8.1"
-  },
   "devDependencies": {
-    "@bufbuild/protobuf": "^2.16.0",
-    "@bufbuild/protoc-gen-es": "^2.16.0",
+    "@bufbuild/protobuf": "^2.17.0",
+    "@bufbuild/protoc-gen-es": "^2.17.0",
     "@connectrpc/connect": "^2.3.0",
     "@connectrpc/connect-web": "^2.3.0",
     "playwright": "1.64.1",
-    "rolldown": "^1.2.16",
+    "rolldown": "^1.3.0",
     "typescript": "^7.0.2"
   },
+  "peerDependencies": {
+    "@bufbuild/protobuf": "^2.17.0"
+  },
   "engines": {
     "node": ">=24"
   },
-  "packageManager": "npm@12.2.1"
+  "packageManager": "npm@12.2.2"
 }

package/src/call.js

@@ -859,5 +859,5 @@ function timeoutField({ timeoutMs }) {
   if (nanos > MaxUint64) {
     throw invalidArgument("RPC timeout does not fit in 64-bit nanoseconds");
   }
-  return { timeoutNanos: String(nanos === 0n ? 1n : nanos) };
+  return { timeoutNanos: nanos === 0n ? 1n : nanos };
 }

package/src/channel.js

@@ -3,7 +3,14 @@ import { ConnectionMetadataSource } from "./connection-metadata.js";
 import { interceptorList } from "./interceptor.js";
 import { QMuxWebSocketSession } from "./qmux/session.js";
 import { dialRace } from "./race.js";
-import { cancelled, failedPrecondition, statusFromTransportError, unavailable } from "./status.js";
+import {
+  Code,
+  TrevRpcError,
+  cancelled,
+  failedPrecondition,
+  statusFromTransportError,
+  unavailable,
+} from "./status.js";
 import { StreamBudget } from "./stream-compression.js";
 
 /**
@@ -63,7 +70,7 @@ export class Channel {
     try {
       const failure = await channel.#connecting;
       if (signal?.aborted) {
-        throw abortError(signal);
+        throw abortError(signal, failure);
       }
       if (failure !== undefined) {
         throw failure;
@@ -433,7 +440,13 @@ function dialWebSocket(url, options, signal) {
  * may reject the ready session by throwing.
  */
 async function establish(session, name, signal, verify) {
-  const abandon = () => closeQuietly(session);
+  const startedAt = Date.now();
+  let abandoned;
+  const abandon = () => {
+    // Closing ends the session, so how far it got is recorded first.
+    abandoned = abandonedMessage(session, name, startedAt);
+    closeQuietly(session);
+  };
   signal?.addEventListener("abort", abandon, { once: true });
   try {
     // A session that fails to connect settles both promises; one that closes first never becomes
@@ -447,7 +460,10 @@ async function establish(session, name, signal, verify) {
     verify?.(session);
   } catch (error) {
     closeQuietly(session);
-    throw signal?.aborted ? abortError(signal) : statusFromTransportError(error);
+    if (signal?.aborted) {
+      throw cancelled(abandoned ?? abandonedMessage(session, name, startedAt), signal.reason);
+    }
+    throw statusFromTransportError(error);
   } finally {
     signal?.removeEventListener("abort", abandon);
   }
@@ -468,8 +484,30 @@ function transportOptions(options) {
   return picked;
 }
 
-function abortError(signal) {
-  return cancelled("connection cancelled", signal.reason);
+/**
+ * The Cancelled error of a connection attempt that `signal` aborted. It keeps the message of
+ * `failure`, the attempt's own Cancelled error, which says how far the attempt got.
+ */
+function abortError(signal, failure) {
+  const message =
+    failure instanceof TrevRpcError && failure.code === Code.Cancelled
+      ? failure.statusMessage
+      : "connection cancelled";
+  return cancelled(message, signal.reason);
+}
+
+/**
+ * Says how far a session abandoned `startedAt` (from Date.now()) got: a QMux over WebSocket
+ * session tells the WebSocket opening from the QMux handshake; a WebTransport session cannot.
+ */
+function abandonedMessage(session, name, startedAt) {
+  const progress =
+    {
+      opening: "the WebSocket was still opening",
+      handshaking:
+        "the WebSocket was open, but the server had not sent its QMux transport parameters",
+    }[session.stage] ?? `the ${name} session was not ready`;
+  return `connection cancelled after ${Date.now() - startedAt} ms: ${progress}`;
 }
 
 /** Exponential backoff with jitter, capped at maxDelayMs. */

package/src/client.js

@@ -1,16 +1,20 @@
 import { Call, EarlyOk, defaultCallOptions, mergeCallOptions } from "./call.js";
-import { FrameType, marshalMessage, unmarshalMessage } from "./framing.js";
-import { int64Converter } from "./int64.js";
+import { FrameType, decodeWireMessage, marshalMessage, unmarshalMessage } from "./framing.js";
 import { interceptCall, interceptorList } from "./interceptor.js";
 import { validateMetadata } from "./metadata.js";
-import { Code, cancelled, internal, statusError } from "./status.js";
+import { methodSettings } from "./method-options.js";
+import { Code, cancelled, internal, invalidArgument, statusError } from "./status.js";
 import { RpcAnswer, RpcHeaders, RpcKind, RpcStatus } from "./wire.js";
 
 /**
- * Creates a service client from a generated service descriptor. Its calls run the interceptors of
- * the transport, then those of `options.interceptors`.
+ * Creates a client for `service`, a service descriptor that protoc-gen-es generates, with one
+ * function per method, named by the method's `localName`. Its calls run the interceptors of the
+ * transport, then those of `options.interceptors`.
  */
-export function createServiceClient(transport, service, root, options = {}) {
+export function createClient(service, transport, options = {}) {
+  if (service?.kind !== "service" || !Array.isArray(service.methods)) {
+    throw invalidArgument("createClient needs a protobuf-es service descriptor");
+  }
   const { interceptors: clientInterceptors, ...callOptions } = options;
   const defaults = mergeCallOptions(defaultCallOptions(), callOptions);
   const interceptors = [
@@ -19,32 +23,26 @@ export function createServiceClient(transport, service, root, options = {}) {
   ];
   const client = {};
 
-  for (const [jsName, method] of Object.entries(service.methods)) {
-    const requestType = root.lookupType(method.inputType);
-    const responseType = root.lookupType(method.outputType);
+  for (const method of service.methods) {
+    const settings = methodSettings(method);
     const rpc = {
       // The wire method path, computed once per method rather than per call.
-      path: `/${service.fullName}/${method.name}`,
-      requestType,
-      responseType,
-      // Converts the 64-bit integers of decoded responses, or undefined when they need nothing.
-      convertResponse: int64Converter(responseType),
+      path: `/${service.typeName}/${method.name}`,
+      requestType: method.input,
+      responseType: method.output,
       // Full protobuf names, which pick the compression dictionaries.
-      types: { request: fullName(requestType), response: fullName(responseType) },
-      datagrams: datagramUse(method),
-      compressStream: streamCompressionUse(method),
-      compress: plainCompressionUse(method),
+      types: { request: method.input.typeName, response: method.output.typeName },
+      datagrams: datagramUse(settings),
+      compressStream: streamCompressionUse(settings),
+      compress: plainCompressionUse(settings),
     };
     const resolve = (override) => mergeCallOptions(defaults, override);
-    const shape = MethodShapes[method.kind];
-    if (shape === undefined) {
-      throw internal(`unsupported generated RPC kind ${JSON.stringify(method.kind)}`);
-    }
+    const shape = MethodShapes[settings.kind];
     const info = {
       method: rpc.path,
-      service: service.fullName,
+      service: service.typeName,
       name: method.name,
-      kind: method.kind,
+      kind: settings.kind,
     };
     const call =
       interceptors.length === 0
@@ -57,7 +55,7 @@ export function createServiceClient(transport, service, root, options = {}) {
               (options) => shape.start(transport, rpc, request, options),
               shape.ended,
             );
-    client[jsName] = shape.takesRequest ? call : (override) => call(undefined, override);
+    client[method.localName] = shape.takesRequest ? call : (override) => call(undefined, override);
   }
 
   return client;
@@ -183,7 +181,7 @@ const ReadAheadBytes = 1 << 20;
  * How a method uses datagrams, or undefined if it does not: `send` for request messages, which
  * needs a streaming request and `unreliableRequests`, and `receive` for response messages, which
  * every call with a streaming response accepts. A method needs a flow if it marks either
- * direction unreliable; the generator rejects marks on a direction that does not stream.
+ * direction unreliable; methodSettings rejects marks on a direction that does not stream.
  */
 function datagramUse({ kind, unreliableRequests, unreliableResponses }) {
   const streamsRequest = kind === "clientStreaming" || kind === "bidirectionalStreaming";
@@ -196,7 +194,7 @@ function datagramUse({ kind, unreliableRequests, unreliableResponses }) {
 
 /**
  * The directions a method may stream-compress, `{ requests, responses }`, or undefined for none:
- * those its descriptor marks (the generator leaves out directions that do not stream and message
+ * those its settings mark (methodSettings leaves out directions that do not stream and message
  * types with redacted fields), except directions marked unreliable, whose messages mostly travel
  * as datagrams.
  */
@@ -208,7 +206,7 @@ function streamCompressionUse({ compressStreamRequests, compressStreamResponses,
 
 /**
  * The directions whose messages a method may compress without a dictionary, `{ requests,
- * responses }`, or undefined for none: those its descriptor marks (the generator marks both for
+ * responses }`, or undefined for none: those its settings mark (methodSettings marks both for
  * `COMPRESSION_MESSAGE` and `COMPRESSION_STREAM`, except message types with redacted fields).
  */
 function plainCompressionUse({ compressRequests, compressResponses }) {
@@ -418,8 +416,7 @@ export class BidirectionalStreamingCall {
     const item = await this.#take();
     if (item.payload !== undefined) {
       try {
-        const message = unmarshalMessage(this.#rpc.responseType, item.payload);
-        return this.#rpc.convertResponse?.(message) ?? message;
+        return unmarshalMessage(this.#rpc.responseType, item.payload);
       } catch (error) {
         throw this.#settleFailure(this.#call.fail(error));
       }
@@ -594,7 +591,7 @@ export class BidirectionalStreamingCall {
             );
           }
           this.#sawAnswer = true;
-          this.#call.learnAnswers(unmarshalMessage(RpcAnswer, frame.payload));
+          this.#call.learnAnswers(decodeWireMessage(RpcAnswer, frame.payload));
           continue;
         }
         case FrameType.Headers: {
@@ -603,7 +600,7 @@ export class BidirectionalStreamingCall {
               this.#sawHeaders ? "duplicate HEADERS frame" : "HEADERS frame after MESSAGE",
             );
           }
-          const headers = unmarshalMessage(RpcHeaders, frame.payload);
+          const headers = decodeWireMessage(RpcHeaders, frame.payload);
           validateResponseMetadata(headers.metadata, "headers");
           this.#sawHeaders = true;
           this.#settleHeaders(headers.metadata);
@@ -620,7 +617,7 @@ export class BidirectionalStreamingCall {
           return { type: FrameType.Message, payload };
         }
         case FrameType.Status: {
-          const status = unmarshalMessage(RpcStatus, frame.payload);
+          const status = decodeWireMessage(RpcStatus, frame.payload);
           if (status.refusedStreamCompression && this.#call.replayable) {
             // The server refused the optimistic call before running anything for it: the call
             // continues on a replay, and its response is read from there.
@@ -791,11 +788,6 @@ function requestFields(rpc, kind) {
   return { method: rpc.path, kind };
 }
 
-/** The full name of a protobuf.js message type, without the leading dot. */
-function fullName(type) {
-  return type.fullName.replace(/^\./u, "");
-}
-
 function validateResponseMetadata(metadata, what) {
   try {
     validateMetadata(metadata);

package/src/framing.js

@@ -1,7 +1,9 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+
 import { byteView } from "./bytes.js";
 import { internal, invalidArgument, resourceExhausted, unavailable } from "./status.js";
 import { readVarint, varintLength, writeVarint } from "./varint.js";
-import { RpcAnswer, RpcHeaders, RpcRequest, RpcStatus, preflightWireMessage } from "./wire.js";
+import { RpcAnswer, RpcHeaders, RpcRequest, RpcStatus } from "./wire.js";
 
 export const DefaultMaxFrameSize = 4 * 1024 * 1024;
 
@@ -19,10 +21,13 @@ export const FrameType = Object.freeze({
 const KnownFrameTypes = new Set(Object.values(FrameType));
 const EmptyBytes = new Uint8Array(0);
 
-/** Encodes a protobuf message body. */
-export function marshalMessage(messageType, message) {
+/**
+ * Encodes a protobuf message body: `message` is a message of `schema` (a protobuf-es message
+ * descriptor) or the init object `create()` takes.
+ */
+export function marshalMessage(schema, message) {
   try {
-    return messageType.encode(messageType.fromObject(message)).finish();
+    return toBinary(schema, create(schema, message));
   } catch (error) {
     throw invalidArgument(
       `failed to encode protobuf message: ${error?.message ?? String(error)}`,
@@ -31,11 +36,10 @@ export function marshalMessage(messageType, message) {
   }
 }
 
-/** Decodes a protobuf message body, rejecting malformed wire data. */
-export function unmarshalMessage(messageType, body) {
+/** Decodes a protobuf message body of `schema`, rejecting malformed wire data. */
+export function unmarshalMessage(schema, body) {
   try {
-    preflightWireMessage(messageType, body);
-    return messageType.decode(body);
+    return fromBinary(schema, byteView(body));
   } catch (error) {
     throw invalidArgument(
       `failed to decode protobuf message: ${error?.message ?? String(error)}`,
@@ -44,6 +48,30 @@ export function unmarshalMessage(messageType, body) {
   }
 }
 
+/** Encodes a wire payload with its codec from wire.js, such as RpcStatus. */
+export function encodeWireMessage(codec, fields) {
+  try {
+    return codec.encode(fields);
+  } catch (error) {
+    throw invalidArgument(
+      `failed to encode ${codec.name}: ${error?.message ?? String(error)}`,
+      error,
+    );
+  }
+}
+
+/** Decodes a wire payload with its codec from wire.js, rejecting malformed wire data. */
+export function decodeWireMessage(codec, payload) {
+  try {
+    return codec.decode(byteView(payload));
+  } catch (error) {
+    throw invalidArgument(
+      `failed to decode ${codec.name}: ${error?.message ?? String(error)}`,
+      error,
+    );
+  }
+}
+
 /** Encodes one frame carrying an already-encoded payload. */
 export function encodeFrame(type, payload, maxFrameSize = DefaultMaxFrameSize) {
   checkFrameLength(payload.byteLength, maxFrameSize);
@@ -71,7 +99,7 @@ export function encodeOutgoingFrame(message, maxFrameSize = DefaultMaxFrameSize)
  * encodeMessage, when it is given, in one buffer so both go out in a single write.
  */
 export function encodeRequestFrame(request, message, maxFrameSize = DefaultMaxFrameSize) {
-  const payload = marshalMessage(RpcRequest, request);
+  const payload = encodeWireMessage(RpcRequest, request);
   checkFrameLength(payload.byteLength, maxFrameSize);
   if (message === undefined) {
     return encodeFrame(FrameType.Request, payload, maxFrameSize);
@@ -86,17 +114,17 @@ export function encodeRequestFrame(request, message, maxFrameSize = DefaultMaxFr
 
 /** Encodes a HEADERS frame from RpcHeaders fields. */
 export function encodeHeadersFrame(headers, maxFrameSize = DefaultMaxFrameSize) {
-  return encodeFrame(FrameType.Headers, marshalMessage(RpcHeaders, headers), maxFrameSize);
+  return encodeFrame(FrameType.Headers, encodeWireMessage(RpcHeaders, headers), maxFrameSize);
 }
 
 /** Encodes an ANSWER frame from RpcAnswer fields. */
 export function encodeAnswerFrame(answer, maxFrameSize = DefaultMaxFrameSize) {
-  return encodeFrame(FrameType.Answer, marshalMessage(RpcAnswer, answer), maxFrameSize);
+  return encodeFrame(FrameType.Answer, encodeWireMessage(RpcAnswer, answer), maxFrameSize);
 }
 
 /** Encodes a STATUS frame from RpcStatus fields. */
 export function encodeStatusFrame(status, maxFrameSize = DefaultMaxFrameSize) {
-  return encodeFrame(FrameType.Status, marshalMessage(RpcStatus, status), maxFrameSize);
+  return encodeFrame(FrameType.Status, encodeWireMessage(RpcStatus, status), maxFrameSize);
 }
 
 /**