@hydranium/protocol 1.0.0-next.11 → 1.0.0-next.112

package/src/messages/primitives.ts

@@ -0,0 +1,250 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { ResponseError } from 'vscode-jsonrpc';
+
+/**
+ * The framework externalizes user-facing strings and SELECTS no locale: it
+ * relays the one its client declared and renders with whatever templates the
+ * adopter installed, defaulting to its English. Every such string carries a
+ * stable code beside that English, and exactly one side renders it — the side
+ * that knows the reading user's language.
+ *
+ * Which side that is depends on the message, not on the package. A server
+ * message is rendered by the server, at the one seam every carrier passes
+ * through, in the locale it was handed at init. A message the client tier raises
+ * is rendered there, because those fire when the server is unreachable. Nothing
+ * is rendered twice: two renders of one sentence are two authorities over it,
+ * and they diverge on the first reword.
+ *
+ * Codes are `hydranium/<unscoped-package>/<name>`. The package segment locates
+ * the declaration, so a message is declared in the package that raises it and a
+ * code never names a package it does not live in. `.` and `:` are forbidden in a
+ * segment: they are i18next's default key and namespace separators, where either
+ * silently becomes a nested lookup that misses.
+ */
+export type MessageParams = Readonly<Record<string, string | number>>;
+
+type Placeholder<S extends string> = S extends `${string}{${infer Name}}${infer Rest}` ? Name | Placeholder<Rest> : never;
+
+export type ParamsOf<S extends string> = [Placeholder<S>] extends [never]
+   ? Record<never, never>
+   : Readonly<Record<Placeholder<S>, string | number>>;
+
+/** Required exactly when the text has placeholders, absent when it does not. */
+export type ParamsArg<S extends string> = [Placeholder<S>] extends [never] ? [] : [params: ParamsOf<S>];
+
+/**
+ * Rejects a text argument already widened to `string`. Load-bearing rather than
+ * defensive: the whole compile-time guarantee is conditional on `S` inferring a
+ * literal, and for a concatenated or pre-widened text the placeholder set
+ * silently becomes empty, `format()` accepts no arguments, and the missing
+ * substitution surfaces only at runtime.
+ */
+export type LiteralText<S extends string> = string extends S ? never : S;
+
+export interface MessageDefinition<S extends string> {
+   readonly code: string;
+   readonly text: S;
+   format(...args: ParamsArg<S>): string;
+}
+
+/**
+ * Declare a message. Placeholder names are inferred from `text` rather than
+ * declared again in a type argument: a second spelling of every name is the
+ * repetition that drifts, since adding a placeholder to the sentence and not to
+ * the type compiles.
+ */
+export function defineMessage<S extends string>(code: string, text: LiteralText<S>): MessageDefinition<S> {
+   const literal = text as S;
+   return { code, text: literal, format: (...args) => interpolate(literal, args[0] ?? {}) };
+}
+
+const PLACEHOLDER = /\{([^}]+)\}/g;
+
+/**
+ * Substitute `{name}` tokens, leaving an unfilled token in place.
+ *
+ * It must not throw. This runs over an adopter's translation as well as our own
+ * text, so a typo in a foreign catalogue has to degrade to a slightly wrong
+ * sentence rather than raise inside a toast render. Re-scanning the result to
+ * detect an unfilled token is what an earlier form did, and it cannot work:
+ * `String.replace` does not rescan replacement text, so the check could not tell
+ * an unfilled placeholder from user data shaped like one — an element literally
+ * named `{separator}` crashed at the authoring site.
+ */
+export function interpolate(template: string, params: MessageParams): string {
+   // Indexed rather than `key in params`: a hand-built or version-skewed
+   // identity can arrive with no params at all, and `in` throws on a non-object
+   // where a lookup degrades.
+   const lookup = params as Record<string, string | number | undefined> | undefined;
+   return template.replace(PLACEHOLDER, (match, key: string) => {
+      const value = lookup?.[key];
+      return value === undefined ? match : String(value);
+   });
+}
+
+export interface MessageIdentity {
+   readonly code: string;
+   readonly params: MessageParams;
+}
+
+/**
+ * Envelope for a protocol `data` field. Namespaced under one key so it co-exists
+ * with a carrier's own `data` conventions rather than occupying `data` itself.
+ */
+export interface HydraniumMessageData {
+   readonly hydranium: MessageIdentity;
+}
+
+/** An identity plus its resolved English — everything a renderer needs, on any carrier. */
+export interface ResolvedMessage extends MessageIdentity {
+   readonly text: string;
+}
+
+export function messageData<S extends string>(message: MessageDefinition<S>, ...args: ParamsArg<S>): HydraniumMessageData {
+   return { hydranium: { code: message.code, params: args[0] ?? {} } };
+}
+
+/**
+ * Identity plus resolved English, for a hand-off carrying a value rather than a
+ * protocol field. The result is structured-clone safe, so it survives a process
+ * hop where one intervenes and costs nothing where none does.
+ */
+export function resolve<S extends string>(message: MessageDefinition<S>, ...args: ParamsArg<S>): ResolvedMessage {
+   return { code: message.code, text: message.format(...args), params: args[0] ?? {} };
+}
+
+/**
+ * Validates every field {@link MessageIdentity} declares, `params` included.
+ * A guard over foreign input that checks only `code` while declaring `params`
+ * non-optional hands `undefined` to the renderer, which fails with the worst
+ * polarity available: invisible in English, crashing only once a translation is
+ * loaded.
+ */
+export function hasMessageIdentity(data: unknown): data is HydraniumMessageData {
+   if (typeof data !== 'object' || data === null || Array.isArray(data) || !('hydranium' in data)) {
+      return false;
+   }
+   const identity = (data as { hydranium: unknown }).hydranium;
+   if (typeof identity !== 'object' || identity === null || Array.isArray(identity)) {
+      return false;
+   }
+   const candidate = identity as Partial<MessageIdentity>;
+   return typeof candidate.code === 'string' && typeof candidate.params === 'object' && candidate.params !== null;
+}
+
+/**
+ * A type alias rather than a subclass. Only `code`, `message` and `data` cross
+ * the wire, so a subclass buys nothing there: `instanceof` does not survive
+ * reconstruction, and the subclass costs an `Object.setPrototypeOf` in every
+ * constructor purely to undo what `ResponseError`'s own constructor does.
+ */
+export type HydraniumResponseError = ResponseError<HydraniumMessageData>;
+
+/**
+ * The numeric `code` and the message's catalogue code are unrelated and both are
+ * needed: `ResponseError.code` is an `integer`, so it cannot hold a
+ * `hydranium/…` key, and it is what a caller switches on after reconstruction.
+ */
+export function messageError<S extends string>(
+   code: number,
+   message: MessageDefinition<S>,
+   ...params: ParamsArg<S>
+): HydraniumResponseError {
+   return new ResponseError(code, message.format(...params), messageData(message, ...params));
+}
+
+/**
+ * The reading user's language, as the tag a client declared.
+ *
+ * Neither validated nor normalised anywhere: rejecting an unfamiliar tag would
+ * be selecting a locale, which the framework does not do.
+ *
+ * NOT a Langium language id, which names a grammar. The two are strings of the
+ * same shape reachable from the same services, so one used where the other
+ * belongs misses every lookup rather than failing.
+ */
+export type Locale = string;
+
+/**
+ * A host's templates for one locale, keyed by the whole message code.
+ *
+ * **Flat, not nested.** A code is one key here, `/` separators included; a host
+ * whose own catalogue format nests — Theia's does — flattens on the way in. A
+ * map that nests instead misses every lookup while type-checking, because the
+ * value this is indexed by is `ResolvedMessage.code`.
+ *
+ * **Partial by nature rather than by convention.** A code with no entry renders
+ * its English default, so a catalogue covering none of a package's codes is a
+ * valid catalogue and not a broken one — which is what lets an adopter translate
+ * as much or as little as they like.
+ *
+ * Deliberately NOT narrowed to the codes that exist, and a `Code extends string`
+ * parameter would not buy what it appears to: a catalogue is loaded as JSON, so
+ * it reaches a checked position as a variable rather than as an object literal,
+ * and excess-property checking — the only thing that would reject a mistyped
+ * key — does not run there. The gain is a compile error for a catalogue with no
+ * correct key at all; the cost is a code union to maintain by hand, since a
+ * declaration does not carry its code as a literal type.
+ */
+export type MessageCatalogue = Readonly<Record<string, string>>;
+
+/**
+ * Render on the side that knows the reading user's locale. Omitting
+ * `translations` is how an adopter without i18n opts out, and yields the
+ * English.
+ */
+export function renderFrameworkMessage(message: ResolvedMessage, translations?: MessageCatalogue): string {
+   const template = translations?.[message.code];
+   return template ? interpolate(template, message.params) : message.text;
+}
+
+export function resolvedFromResponseError(error: ResponseError<unknown>): ResolvedMessage | undefined {
+   return hasMessageIdentity(error.data) ? { ...error.data.hydranium, text: error.message } : undefined;
+}
+
+/**
+ * The detail half of a `{detail}` placeholder. A technical error string is safe
+ * to pass as a parameter for the same reason a number is: it is not itself
+ * translatable text, so it needs no code of its own. A PROSE fragment is not,
+ * and must become one code per value instead.
+ */
+export function describeError(error: unknown): string {
+   return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Recognises a declaration among a barrel's exports. The `format` check is what
+ * discriminates: a `code` + `text` pair alone admits any object that happens to
+ * carry both.
+ */
+export function isMessageDeclaration(value: unknown): value is MessageDefinition<string> {
+   const candidate = value as { code?: unknown; text?: unknown; format?: unknown } | null;
+   return (
+      typeof candidate === 'object' &&
+      candidate !== null &&
+      typeof candidate.code === 'string' &&
+      typeof candidate.text === 'string' &&
+      typeof candidate.format === 'function'
+   );
+}
+
+/**
+ * Every declaration a `./messages` barrel exports.
+ *
+ * A caller cannot get there with `Object.values(barrel).filter(isMessageDeclaration)`:
+ * a barrel's value type is a union of its declarations AND its functions, and
+ * `filter` will not narrow a function type down to a `MessageDefinition`, so the
+ * result stays the union and reading `.code` off it does not compile. Taking the
+ * barrel as an opaque object is what makes the one-liner work.
+ */
+export function collectMessages(barrel: object): MessageDefinition<string>[] {
+   return (Object.values(barrel) as unknown[]).filter(isMessageDeclaration);
+}

package/src/model-server.ts

@@ -47,8 +47,10 @@ export interface OpenModelArgs extends TransferClientArgs {
     * means read from the filesystem, which is the normal case.
     *
     * Honoured only on the first open of a URI: opening an already-open document
-    * is a no-op, so passing `text` for one silently changes nothing. Write
-    * through the update path instead.
+    * attaches the caller to the existing shared entry and does not replace its
+    * content with this seed. Write through the update path instead. The open
+    * response reads the current shared content after registration; a textual
+    * `didOpen` attach may separately refresh the build.
     */
    text?: string;
 }
@@ -64,8 +66,8 @@ export interface CloseModelArgs extends TransferClientArgs {}
 export interface TransferUpdatedEvent<TDocument> {
    document: TDocument;
    sourceClientId: string;
-   /** See `ModelDocumentUpdateReason` in `./data/events` for the canonical reason set + semantics. */
-   reason: 'changed' | 'deleted' | 'rebuilt' | 'saved';
+   /** See `TransferDocumentUpdateReason` in `./data/events` for the canonical reason set + semantics. */
+   reason: 'changed' | 'rebuilt' | 'saved';
 }
 
 export interface TransferSavedEvent<TDocument> {
@@ -147,10 +149,10 @@ export function isElementSource(object: unknown): object is ElementSource {
 /** An element of a document that does not yet exist on disk — used during element creation flows. */
 export interface SyntheticSource {
    /**
-    * The document the element would belong to. That document must already be
-    * LOADED — the default resolution takes its parse root as the synthetic
-    * node's container and answers `undefined` when it is not, so a URI for a
-    * file that exists on disk but was never opened resolves to nothing.
+    * The document the element would belong to. It need not be loaded, or
+    * exist — an unloaded URI materialises a transient empty document, so a
+    * folder is a valid anchor. A URI that IS loaded contributes that
+    * document's parse root as the container, putting its contents in scope.
     */
    uri: string;
    /**
@@ -159,6 +161,16 @@ export interface SyntheticSource {
     * it is what scoping filters candidates against.
     */
    type: string;
+   /**
+    * The grammar the element will belong to, as a language id.
+    *
+    * Optional because `uri` and `type` each answer on their own when
+    * unambiguous. Set it when neither is: a URI naming no file carries no
+    * extension to route on, and a `type` two grammars can produce identifies
+    * neither. Unset, such a source reaches the server's own policy, which
+    * answers the same way for every caller.
+    */
+   language?: string;
 }
 
 export function isSyntheticSource(object: unknown): object is SyntheticSource {
@@ -183,8 +195,10 @@ export namespace ReferenceSource {
    export function element(name: string, type?: string): ElementSource {
       return { name, type };
    }
-   export function synthetic(uri: string, type: string): SyntheticSource {
-      return { uri, type };
+   export function synthetic(uri: string, type: string, language?: string): SyntheticSource {
+      // The key is omitted rather than set to `undefined`, so a source built
+      // without a language stays deep-equal to the two-argument form.
+      return language === undefined ? { uri, type } : { uri, type, language };
    }
 }
 
@@ -457,9 +471,10 @@ export interface FindNextNameArgs {
     */
    uri: string;
    /**
-    * The AST `$type` of the element being named. Collisions are only looked for
-    * among elements of that same type, so the returned name may still be taken
-    * by an element of another type.
+    * The AST `$type` of the element being named. Collisions are looked for
+    * among elements of that type and of any subtype of it, so a supertype
+    * names a uniqueness scope its concrete types share; the returned name may
+    * still be taken by an element outside that hierarchy.
     */
    type: string;
    /**
@@ -476,4 +491,10 @@ export interface FindNextNameArgs {
     * See {@link NameTier} for what each tier covers.
     */
    tier?: NameTier;
+   /**
+    * The grammar to name under, routed as {@link SyntheticSource.language} —
+    * this call builds one. A caller that sets it there must set it here, or
+    * candidates and the name it proposes come from different grammars.
+    */
+   language?: string;
 }

package/src/model-service/args.ts

@@ -19,6 +19,8 @@
  * resolves.
  */
 
+import type { BasedOn } from './based-on';
+
 /** Identifies a client-document binding. Every facade operation carries these fields. */
 export interface TransferClientArgs {
    /** Document URI. */
@@ -39,15 +41,16 @@ export interface TransferUpdateArgs<T> extends TransferClientArgs {
    /** Structured model root or its serialised textual form. */
    model: T | string;
    /**
-    * Optional based-on version: the text-document version this update
-    * was authored against. When set, the server compares against its
-    * current text-document version for `uri` and throws
-    * `ConflictError` on mismatch. Omit to opt out of the gate — mirrors
-    * LSP's `OptionalVersionedTextDocumentIdentifier` posture, intended
-    * for headless / CLI / batch tooling without a meaningful based-on
-    * version.
+    * What this update was authored against. A `SnapshotVersion` is compared
+    * against the server's current text-document version for `uri` and throws
+    * `ConflictError` on mismatch; `'anything'` writes unconditionally.
+    *
+    * **Required so that an ungated write is a decision rather than an
+    * omission.** An optional gate is indistinguishable from a forgotten one at
+    * the call site, and a file of twenty writes hides the one that lost the
+    * field. Nothing else here can see that, since the defect is an absence.
     */
-   baseVersion?: number;
+   basedOn: BasedOn;
 }
 
 /**
@@ -58,10 +61,9 @@ export interface TransferSaveArgs<T> extends TransferClientArgs {
    /** Structured model root or its serialised textual form. */
    model: T | string;
    /**
-    * Optional based-on version — same semantics as
-    * {@link TransferUpdateArgs.baseVersion}. `save` delegates the gating
-    * check to its inner `update`, so this field threads through to the
-    * same `ConflictError` site.
+    * Same semantics and same requirement as {@link TransferUpdateArgs.basedOn}.
+    * `save` delegates the gating check to its inner `update`, so this field
+    * threads through to the same `ConflictError` site.
     */
-   baseVersion?: number;
+   basedOn: BasedOn;
 }

package/src/model-service/based-on.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+declare const snapshotMarker: unique symbol;
+
+/**
+ * A text-document version that came out of a SNAPSHOT read: a document
+ * envelope's `version`, which cannot move once the envelope exists.
+ *
+ * A plain number at runtime, usable anywhere a number is, and it travels the
+ * wire as one. The marker exists only so the compiler can tell it apart from a
+ * version read off a LIVE document, which is the same number type and is the
+ * defect the conflict gate exists to prevent: read at write time it is whatever
+ * the server is at now, which is the number the gate is about to compare it
+ * against, so the gate passes unconditionally and a concurrent edit is
+ * overwritten with nothing logged.
+ */
+export type SnapshotVersion = number & { readonly [snapshotMarker]: true };
+
+/**
+ * What a write declares it was based on: a version from a snapshot read, or
+ * `'anything'`.
+ *
+ * `'anything'` is a precondition that always holds — the write accepts whatever
+ * the server currently has, and therefore overwrites it. It is the honest
+ * answer wherever the write was authored against no particular server version,
+ * and a lie anywhere a reader handed the writer a document. The field carrying
+ * it is required, so an ungated write is a word someone chose rather than a
+ * field someone forgot.
+ */
+export type BasedOn = SnapshotVersion | 'anything';
+
+/**
+ * Whether `basedOn` names a version, and so arms the gate.
+ *
+ * Branch on this rather than on `basedOn !== 'anything'`, which reads as "not
+ * based on anything" — the opposite of what the branch tests.
+ */
+export function isSnapshotVersion(basedOn: BasedOn): basedOn is SnapshotVersion {
+   return typeof basedOn === 'number';
+}
+
+/**
+ * Mark a version as having come from a snapshot read.
+ *
+ * **For the envelope constructors, not for callers.** Every door that builds a
+ * document envelope applies it on the way in, so anything a read returns
+ * already carries it and a writer never needs this. A caller reaching for it is
+ * asserting a provenance the compiler was about to deny — the read-late defect
+ * written out where a reviewer can see it.
+ */
+export function asSnapshotVersion(version: number): SnapshotVersion {
+   return version as SnapshotVersion;
+}

package/src/model-service/index.ts

@@ -13,4 +13,5 @@
 // protocol can structurally agree on the lifecycle shape.
 
 export * from './args';
+export * from './based-on';
 export * from './reference-candidate';

package/src/profile-session.ts

@@ -62,7 +62,12 @@ export interface ProfileSession {
    records(): readonly ProfileRecord[];
 }
 
-interface ScopeFrame {
+/**
+ * One in-flight {@link ProfileSession.scope} call. Held on the `protected`
+ * {@link DefaultProfileSession.stack} and named by
+ * {@link DefaultProfileSession.closeFrame}, so a subclass has to name it too.
+ */
+export interface ProfileScopeFrame {
    readonly id: string;
    /** Session-stopwatch reading when this scope began. */
    readonly start: number;
@@ -78,7 +83,7 @@ interface ScopeFrame {
 export class DefaultProfileSession implements ProfileSession {
    /** Single monotonic timeline for the whole session; per-scope readings are deltas off it. */
    protected readonly sessionStopwatch: Stopwatch;
-   protected readonly stack: ScopeFrame[] = [];
+   protected readonly stack: ProfileScopeFrame[] = [];
    protected readonly entries = new Map<string, number[]>();
 
    constructor(
@@ -92,7 +97,7 @@ export class DefaultProfileSession implements ProfileSession {
    scope<T>(id: string, fn: () => Promise<T>): Promise<T>;
    scope<T>(id: string, fn: () => T): T;
    scope<T>(id: string, fn: () => T | Promise<T>): T | Promise<T> {
-      const frame: ScopeFrame = { id, start: this.sessionStopwatch.elapsedMs, childMs: 0 };
+      const frame: ProfileScopeFrame = { id, start: this.sessionStopwatch.elapsedMs, childMs: 0 };
       this.stack.push(frame);
       let result: T | Promise<T>;
       try {
@@ -118,7 +123,7 @@ export class DefaultProfileSession implements ProfileSession {
    }
 
    /** Pop `frame`, charge its full duration to the parent, and record its self-time. */
-   protected closeFrame(frame: ScopeFrame): void {
+   protected closeFrame(frame: ProfileScopeFrame): void {
       this.stack.pop();
       const duration = this.sessionStopwatch.elapsedMs - frame.start;
       const parent = this.stack[this.stack.length - 1];

package/src/rpc/bind-rpc-methods.ts

@@ -7,7 +7,7 @@
  * SPDX-License-Identifier: MIT
  ********************************************************************************/
 
-import type { MessageConnection } from 'vscode-jsonrpc';
+import { ResponseError, type MessageConnection } from 'vscode-jsonrpc';
 import type { LatencyCollector } from '../latency-collector';
 import { type Disposable, DisposableCollection } from '../util';
 import { defaultIsNotification } from './create-rpc-proxy';
@@ -70,6 +70,36 @@ export interface BindRpcMethodsOptions {
     * Requests and notifications are both timed. Absent by default (no overhead).
     */
    readonly latency?: LatencyCollector;
+
+   /**
+    * Produce the `message` an outgoing rejection carries, so a user-facing
+    * error is rendered by the side that knows the reading user's language.
+    * Applied at this one chokepoint, which is what covers a caller's
+    * additional methods as well as the framework's own.
+    *
+    * Only a `ResponseError` is routed through it — a plain `Error` carries no
+    * identity to render from, and rewriting its message would relabel a
+    * developer-facing failure as a translated one. The rejection is
+    * RECONSTRUCTED rather than mutated, because the thrown value may be a
+    * shared constant; nothing is lost, since only `code`, `message` and `data`
+    * cross the wire and `instanceof` does not survive reconstruction anyway.
+    *
+    * Notifications are not covered, and "they have no reply channel" is only
+    * half the reason — a notification's own PAYLOAD can carry prose. What makes
+    * this sound is where that prose comes from: the only user-facing text on
+    * the data head's client surface is the diagnostics riding the
+    * document-updated and document-saved events, and those are read off
+    * `LangiumDocument.diagnostics`, which the document builder has already
+    * rendered at `Validated`. So they arrive rendered rather than escaping
+    * unrendered. A notification that ever carries prose of its OWN needs its
+    * own render at the raise site, as GLSP's actions do.
+    */
+   readonly renderErrorMessage?: (error: ResponseError<unknown>) => string;
+}
+
+/** The rejection to throw in place of `err`, with its message rendered. */
+function renderRejection(err: unknown, render: (error: ResponseError<unknown>) => string): unknown {
+   return err instanceof ResponseError ? new ResponseError(err.code, render(err), err.data) : err;
 }
 
 /**
@@ -91,8 +121,10 @@ export interface BindRpcMethodsOptions {
  *
  * Errors thrown synchronously from a request handler — or surfaced as a
  * rejected promise — propagate back to the caller through vscode-jsonrpc's
- * standard error envelope. Errors from a notification handler cannot, and are
- * routed to {@link BindRpcMethodsOptions.onNotificationError} instead.
+ * standard error envelope, with the message rendered when
+ * {@link BindRpcMethodsOptions.renderErrorMessage} is supplied. Errors from a
+ * notification handler cannot propagate, and are routed to
+ * {@link BindRpcMethodsOptions.onNotificationError} instead.
  *
  * Accepts either a ready connection or a `Promise<MessageConnection>` —
  * registrations queue until the connection resolves, then attach. The
@@ -154,7 +186,20 @@ export function bindRpcMethods<T extends object>(
                })
             );
          } else {
-            disposables.push(resolved.onRequest(wireName, async (params: unknown) => dispatch(params)));
+            const render = options.renderErrorMessage;
+            disposables.push(
+               resolved.onRequest(wireName, async (params: unknown) => {
+                  if (!render) {
+                     return dispatch(params);
+                  }
+                  try {
+                     // Awaited inside the try, or a rejected promise escapes it.
+                     return await dispatch(params);
+                  } catch (err: unknown) {
+                     throw renderRejection(err, render);
+                  }
+               })
+            );
          }
       }
    };

package/src/rpc/create-rpc-proxy.ts

@@ -136,6 +136,14 @@ export interface CreateRpcProxyOptions<TLocal extends object = never> {
     * `bindRpcMethods` call) still capture per-method latency. Absent by default.
     */
    readonly latency?: BindRpcMethodsOptions['latency'];
+
+   /**
+    * Forwarded to the inbound {@link localTarget} binding: renders the message
+    * an outgoing rejection carries. Only the inbound direction has rejections
+    * to render — the outbound proxy is this side making requests, and a
+    * rejection it receives was rendered by whoever answered.
+    */
+   readonly renderErrorMessage?: BindRpcMethodsOptions['renderErrorMessage'];
 }
 
 /**
@@ -225,7 +233,12 @@ export function createRpcProxy<T extends object, TLocal extends object = never>(
    // connection; see `localTarget` for why no `Disposable` is surfaced.
    const { localTarget, localMethods } = options;
    if (localTarget && localMethods && localMethods.length > 0) {
-      const binding = bindRpcMethods(connection, localTarget, localMethods, { methodNamespace, isNotification, latency: options.latency });
+      const binding = bindRpcMethods(connection, localTarget, localMethods, {
+         methodNamespace,
+         isNotification,
+         latency: options.latency,
+         renderErrorMessage: options.renderErrorMessage
+      });
       resolvedConnection.then(conn => conn.onClose(() => binding.dispose())).catch(() => undefined);
    }