@moltzap/client 2026.506.0 → 2026.508.0

package/dist/ws-client.d.ts

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
-import { Connect, NotConnectedError, RpcServerError, RpcTimeoutError, type AnyTaskCallbackRpcDefinition, type AnyNotificationDefinition, type JsonRpcStringId, type ParamsOf, type ResultOf, type RpcDefinition, type TSchema, type Static } from "@moltzap/protocol";
+import { Connect, NotConnectedError, RpcServerError, RpcTimeoutError, type AnyTaskCallbackRpcDefinition, type AnyNotificationDefinition, type JsonRpcId, type ParamsOf, type ResultOf, type RpcDefinition } from "@moltzap/protocol";
 import { DuplicateServerRpcHandlerError } from "./runtime/errors.js";
-import { type DecodedNotification, type RawDecodedNotification } from "./runtime/frame.js";
+import { type DecodedNotification } from "./runtime/frame.js";
 import { type NotificationSubscription, type SubscriberHandler, type SubscriptionFilter } from "./runtime/subscribers.js";
 import { type CloseInfo } from "./runtime/close-info.js";
 import { type PartitionedDispatcherConfig } from "./internal/app-callback-partitioned-dispatcher.js";
@@ -14,7 +14,7 @@ export declare const RPC_TIMEOUT_MS = 30000;
 export interface RpcCallOptions {
     readonly timeoutMs?: number;
 }
-type ConnectResult = Static<typeof Connect.resultSchema>;
+type ConnectResult = ResultOf<typeof Connect>;
 /**
  * appCallback dispatcher knobs exposed on `MoltZapWsClientOptions`. All optional;
  * defaults from `DEFAULT_PARTITIONED_DISPATCHER_CONFIG`.
@@ -34,59 +34,19 @@ export type AppCallbackDispatcherConfig = Partial<PartitionedDispatcherConfig>;
  * generic InternalError reply.
  *
  * The `unknown`/`unknown` parameter and result types narrow generically
- * against `taskCallbackRpcMethods` at each `handleServerRpc(definition,
+ * against `taskCallbackMethods` at each `handleServerRpc(definition,
  * handler)` call site via the `AnyTaskCallbackRpcDefinition` union. Phase
  * 9b consumer-migration retired the legacy `AppCallbackRpcMap` indirection
  * alongside the appCallback group collapse to a single member.
  */
 export interface ServerRpcContext {
-    readonly requestId: JsonRpcStringId;
+    readonly requestId: JsonRpcId;
     readonly definition: AnyTaskCallbackRpcDefinition;
     readonly traceparent?: string;
 }
-export type ServerRpcHandler<D extends AnyTaskCallbackRpcDefinition = AnyTaskCallbackRpcDefinition> = (params: Static<D["paramsSchema"]>, ctx: ServerRpcContext & {
+export type ServerRpcHandler<D extends AnyTaskCallbackRpcDefinition = AnyTaskCallbackRpcDefinition> = (params: ParamsOf<D>, ctx: ServerRpcContext & {
     readonly definition: D;
-}) => Effect.Effect<Static<D["resultSchema"]>, RpcServerError>;
-/**
- * Pre-validation alias used internally by buffer/waiter machinery —
- * the decoder is payload-opaque so frames carry `params: unknown`
- * until a typed bridge runs `validateNotificationParams`.
- */
-type AnyRawDecodedNotification = RawDecodedNotification<AnyNotificationDefinition>;
-/**
- * Validate `notification.params` against the schema attached by the
- * decoder. Type predicate: a `true` result lifts the input from the
- * raw (`params: unknown`) shape to the validated
- * `DecodedNotification<…>` shape — the compiler-enforced lift the
- * inbound bridges rely on. Logs a structured drift warning and
- * returns `false` on failure. Every typed dispatcher MUST route
- * through this guard before invoking handlers, because the wire
- * decoder is payload-opaque (required for the
- * `delivery/payload-opacity-client` and
- * `boundary/schema-exhaustive-fuzz-client` conformance properties).
- *
- * The signature is non-generic over a single descriptor: the input
- * accepts the broad `AnyRawDecodedNotification` union (distributed
- * over all known descriptors), and the predicate narrows to the
- * matching distributed validated union. Per-descriptor narrowing is
- * the job of the caller's enclosing `is`-predicate
- * (e.g. `acceptTypedNotification<D>`); this helper just gates "params
- * conform to the attached schema." Current call sites:
- * `acceptTypedNotification` below (typed-promise resolver) and
- * `service.ts:handleNotification` (subscriber-fanout dispatch into
- * the typed handler bucket).
- */
-export declare function validateNotificationParams(notification: AnyRawDecodedNotification, logger: WsClientLogger | undefined): notification is DecodedNotification<AnyNotificationDefinition>;
-/**
- * Typed bridge for `waitForNotification`: matches the notification's
- * descriptor against `definition` and then validates its params via
- * `validateNotificationParams`. A frame whose method matches `definition`
- * but whose params fail validation is logged and skipped — the typed
- * promise never resolves with a malformed payload typed as if it were
- * valid. "Skip on non-match" semantics for the bucketed waiter map are
- * preserved; the validation guard is the lift from raw to validated.
- */
-export declare function acceptTypedNotification<D extends AnyNotificationDefinition>(definition: D, notification: AnyRawDecodedNotification, logger: WsClientLogger | undefined): notification is DecodedNotification<D>;
+}) => Effect.Effect<ResultOf<D>, RpcServerError>;
 export interface WsClientLogger {
     info: (...args: unknown[]) => void;
     warn: (...args: unknown[]) => void;
@@ -118,16 +78,7 @@ export interface MoltZapWsClientOptions {
     appCallbackDispatcher?: AppCallbackDispatcherConfig;
 }
 /**
- * Return shape of `MoltZapWsClient.sendRpcTracked`. Surfaces the outbound
- * request `id` alongside the typed result without leaking the JSON-RPC wire
- * object onto the caller surface.
- */
-export interface TrackedRpcResponse<R> {
-    readonly id: JsonRpcStringId;
-    readonly result: R;
-}
-/**
- * WebSocket lifecycle: open → auth/connect → active. On disconnect,
+ * WebSocket lifecycle: open → network/connect → active. On disconnect,
  * exponential backoff (1s base, 30s cap, jittered) retries the handshake via
  * `Effect.sleep` + `Schedule` so TestClock can drive it. Public API is
  * Effect-based — consumers run the returned Effects themselves (typically at
@@ -184,7 +135,7 @@ export declare class MoltZapWsClient {
      */
     handleServerRpc<D extends AnyTaskCallbackRpcDefinition>(definition: D, handler: ServerRpcHandler<D>): Effect.Effect<void, DuplicateServerRpcHandlerError>;
     get helloOk(): ConnectResult | null;
-    /** Open the socket, perform auth/connect, resolve with HelloOk. Fails
+    /** Open the socket, perform network/connect, resolve with HelloOk. Fails
      * immediately on pre-open close or error. */
     connect(): Effect.Effect<ConnectResult, NotConnectedError | RpcTimeoutError | RpcServerError>;
     /**
@@ -196,19 +147,7 @@ export declare class MoltZapWsClient {
      * Descriptor-backed RPC call. Callers pass the protocol descriptor, and the
      * client extracts the wire method only inside the encoder path.
      */
-    sendRpc<D extends RpcDefinition<string, TSchema, TSchema>>(definition: D, params: ParamsOf<D>, opts?: RpcCallOptions): Effect.Effect<ResultOf<D>, NotConnectedError | RpcTimeoutError | RpcServerError>;
-    /**
-     * Send an RPC and surface the outbound request id alongside the
-     * response envelope `type` and `result`. Spec #222 §5.1–5.2:
-     * un-vacuates B4 (request-id tracking) and V5 (response-type
-     * exposure). Mirrors `sendRpc`'s descriptor-backed call shape.
-     *
-     * Invariant 3 (spec #222 §4): the returned `id` is the same identity
-     * minted inside the existing `rpc-${++counter}` site — no parallel
-     * counter, no mirror. The single-id pre-condition is what makes B4 a
-     * real check rather than a tautology.
-     */
-    sendRpcTracked<D extends RpcDefinition<string, TSchema, TSchema>>(definition: D, params: ParamsOf<D>): Effect.Effect<TrackedRpcResponse<ResultOf<D>>, NotConnectedError | RpcTimeoutError | RpcServerError>;
+    sendRpc<D extends RpcDefinition<string, any, any>>(definition: D, params: ParamsOf<D>, opts?: RpcCallOptions): Effect.Effect<ResultOf<D>, NotConnectedError | RpcTimeoutError | RpcServerError>;
     /**
      * Register a per-subscription notification handler. Spec #222 §5.3 + OQ-2
      * (A): filter grammar is the three-field `SubscriptionFilter`
@@ -236,28 +175,11 @@ export declare class MoltZapWsClient {
     /** Return all buffered notifications and clear the buffer. Synchronous.
      * Frames are pre-validation (`params: unknown`) — buffer holds the
      * raw shape produced by the wire decoder. */
-    drainNotifications(): AnyRawDecodedNotification[];
+    drainNotifications(): DecodedNotification<AnyNotificationDefinition>[];
     /** Close the socket without marking as permanently closed, triggering reconnection. */
     disconnect(): Effect.Effect<void, never>;
     private disconnectSync;
     private connectEffect;
-    /**
-     * Tracked variant of `sendRpcEffect`. Reuses the same Deferred /
-     * pendingRef plumbing — the only difference is the resolved value:
-     * `{id, result}` instead of bare `result`. This
-     * keeps Invariant 3 (single id source) trivially: we mint `id` once
-     * inside this body, register the Deferred under that id, and return
-     * the same id to the caller alongside the result.
-     */
-    private sendRpcTrackedEffect;
-    /**
-     * Bare-result RPC — projects the tracked RPC envelope onto its
-     * `result` field, discarding the `{id, type}` observability surface.
-     * The write / race / timeout plumbing lives in `sendRpcTrackedEffect`
-     * so there is one shared site for Invariant 3 (single id source),
-     * Invariant 5 (typed error channel), and the `socket.writer` latch
-     * race described below.
-     */
     private sendRpcEffect;
     /**
      * Translate a typed `OfferRejected` failure from the partitioned

package/dist/ws-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws-client.d.ts","sourceRoot":"","sources":["../src/ws-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ws-client.d.ts","sourceRoot":"","sources":["../src/ws-client.ts"],"names":[],"mappings":"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"}

package/dist/ws-client.js

@@ -1,9 +1,9 @@
 import * as Socket from "@effect/platform/Socket";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 import { Cause, Data, Deferred, Duration, Either, Effect, Exit, Fiber, HashMap, ManagedRuntime, Option, Ref, Schedule, Scope, } from "effect";
-import { PROTOCOL_VERSION, Connect, decodeRpcResult, jsonRpcStringId, NotConnectedError, requestFrame, responseFrame, RpcServerError, RpcTimeoutError, } from "@moltzap/protocol";
+import { PROTOCOL_VERSION, Connect, encodeErrorResponse, NotConnectedError, RpcServerError, RpcTimeoutError, } from "@moltzap/protocol";
 import { DuplicateServerRpcHandlerError } from "./runtime/errors.js";
-import { decodeFrames, } from "./runtime/frame.js";
+import { decodeFrames } from "./runtime/frame.js";
 import { makeSubscriberRegistry, } from "./runtime/subscribers.js";
 import { extractCloseInfo } from "./runtime/close-info.js";
 import { makePartitionedDispatcher, } from "./internal/app-callback-partitioned-dispatcher.js";
@@ -39,52 +39,13 @@ const UTF8_DECODER = new TextDecoder("utf-8");
 const makeNotConnectedError = () => new NotConnectedError({ message: MSG_NOT_CONNECTED });
 class ReconnectAttemptFailedError extends Data.TaggedError("ReconnectAttemptFailedError") {
 }
-function notificationMatches(definition, notification) {
+/** Notifications are pre-validated by the wire decoder
+ * (`decodeNotification` in `@moltzap/protocol`) — fail-close on unknown
+ * methods or bad params. Buffer + waiters hold the validated shape
+ * directly; no separate Raw|Unknown lift remains. */
+function acceptTypedNotification(definition, notification) {
     return notification.definition === definition;
 }
-/**
- * Validate `notification.params` against the schema attached by the
- * decoder. Type predicate: a `true` result lifts the input from the
- * raw (`params: unknown`) shape to the validated
- * `DecodedNotification<…>` shape — the compiler-enforced lift the
- * inbound bridges rely on. Logs a structured drift warning and
- * returns `false` on failure. Every typed dispatcher MUST route
- * through this guard before invoking handlers, because the wire
- * decoder is payload-opaque (required for the
- * `delivery/payload-opacity-client` and
- * `boundary/schema-exhaustive-fuzz-client` conformance properties).
- *
- * The signature is non-generic over a single descriptor: the input
- * accepts the broad `AnyRawDecodedNotification` union (distributed
- * over all known descriptors), and the predicate narrows to the
- * matching distributed validated union. Per-descriptor narrowing is
- * the job of the caller's enclosing `is`-predicate
- * (e.g. `acceptTypedNotification<D>`); this helper just gates "params
- * conform to the attached schema." Current call sites:
- * `acceptTypedNotification` below (typed-promise resolver) and
- * `service.ts:handleNotification` (subscriber-fanout dispatch into
- * the typed handler bucket).
- */
-export function validateNotificationParams(notification, logger) {
-    if (notification.definition.validateParams(notification.params))
-        return true;
-    logger?.warn(`Notification ${notification.definition.name} dropped: params failed schema validation (drift signal)`, notification.params);
-    return false;
-}
-/**
- * Typed bridge for `waitForNotification`: matches the notification's
- * descriptor against `definition` and then validates its params via
- * `validateNotificationParams`. A frame whose method matches `definition`
- * but whose params fail validation is logged and skipped — the typed
- * promise never resolves with a malformed payload typed as if it were
- * valid. "Skip on non-match" semantics for the bucketed waiter map are
- * preserved; the validation guard is the lift from raw to validated.
- */
-export function acceptTypedNotification(definition, notification, logger) {
-    if (!notificationMatches(definition, notification))
-        return false;
-    return validateNotificationParams(notification, logger);
-}
 /** Drop `waiter` from its notification-definition bucket, pruning an empty bucket. */
 function removeWaiter(m, definition, waiter) {
     const bucket = HashMap.get(m, definition);
@@ -96,7 +57,7 @@ function removeWaiter(m, definition, waiter) {
         : HashMap.set(m, definition, filtered);
 }
 /**
- * WebSocket lifecycle: open → auth/connect → active. On disconnect,
+ * WebSocket lifecycle: open → network/connect → active. On disconnect,
  * exponential backoff (1s base, 30s cap, jittered) retries the handshake via
  * `Effect.sleep` + `Schedule` so TestClock can drive it. Public API is
  * Effect-based — consumers run the returned Effects themselves (typically at
@@ -184,7 +145,7 @@ export class MoltZapWsClient {
     get helloOk() {
         return this._helloOk;
     }
-    /** Open the socket, perform auth/connect, resolve with HelloOk. Fails
+    /** Open the socket, perform network/connect, resolve with HelloOk. Fails
      * immediately on pre-open close or error. */
     connect() {
         return Effect.suspend(() => {
@@ -216,26 +177,6 @@ export class MoltZapWsClient {
                 data: result,
             }))));
     }
-    /**
-     * Send an RPC and surface the outbound request id alongside the
-     * response envelope `type` and `result`. Spec #222 §5.1–5.2:
-     * un-vacuates B4 (request-id tracking) and V5 (response-type
-     * exposure). Mirrors `sendRpc`'s descriptor-backed call shape.
-     *
-     * Invariant 3 (spec #222 §4): the returned `id` is the same identity
-     * minted inside the existing `rpc-${++counter}` site — no parallel
-     * counter, no mirror. The single-id pre-condition is what makes B4 a
-     * real check rather than a tautology.
-     */
-    sendRpcTracked(definition, params) {
-        return this.sendRpcTrackedEffect(definition, params).pipe(Effect.flatMap((tracked) => definition.validateResult(tracked.result)
-            ? Effect.succeed({ id: tracked.id, result: tracked.result })
-            : Effect.fail(new RpcServerError({
-                code: JSON_RPC_INTERNAL_ERROR_CODE,
-                message: `Invalid result for method: ${definition.name}`,
-                data: tracked.result,
-            }))));
-    }
     /**
      * Register a per-subscription notification handler. Spec #222 §5.3 + OQ-2
      * (A): filter grammar is the three-field `SubscriptionFilter`
@@ -307,10 +248,9 @@ export class MoltZapWsClient {
      * with a per-call timeout. */
     waitForNotification(definition, timeoutMs = EVENT_WAIT_TIMEOUT_MS) {
         return Effect.gen(this, function* () {
-            const logger = this.options.logger;
             const buffered = yield* Ref.modify(this.notificationsBufferRef, (frames) => {
                 for (const [idx, frame] of frames.entries()) {
-                    if (!acceptTypedNotification(definition, frame, logger))
+                    if (!acceptTypedNotification(definition, frame))
                         continue;
                     const next = [...frames.slice(0, idx), ...frames.slice(idx + 1)];
                     return [frame, next];
@@ -322,7 +262,7 @@ export class MoltZapWsClient {
             const deferred = yield* Deferred.make();
             const waiter = {
                 definition,
-                complete: (notification) => acceptTypedNotification(definition, notification, logger)
+                complete: (notification) => acceptTypedNotification(definition, notification)
                     ? Deferred.succeed(deferred, notification).pipe(Effect.asVoid)
                     : Effect.void,
                 fail: (error) => Deferred.fail(deferred, error).pipe(Effect.asVoid),
@@ -391,7 +331,7 @@ export class MoltZapWsClient {
                 this.runtime.runFork(Scope.close(scope, Exit.void));
             }).pipe(Effect.zipRight(Effect.fail(makeNotConnectedError()))))));
             const write = yield* Scope.extend(socket.writer, scope);
-            // Settled first by whichever fires: the auth/connect response, or
+            // Settled first by whichever fires: the network/connect response, or
             // reader-fiber exit on any close/error before handshake.
             const handshakeSettled = yield* Deferred.make();
             // Spec #356 — partitioned task-callback dispatcher. Replaces
@@ -474,7 +414,7 @@ export class MoltZapWsClient {
             // finalizes on return, interrupts the reader, and `onExit` clears
             // `_helloOk` behind a caller that believed connect() succeeded.
             const readerFiber = this.runtime.runFork(readerEffect);
-            // Publish state BEFORE auth/connect: the write goes through
+            // Publish state BEFORE network/connect: the write goes through
             // `sendRpcEffect`, which reads `stateRef`.
             yield* Ref.set(this.stateRef, Option.some({
                 write,
@@ -489,9 +429,9 @@ export class MoltZapWsClient {
                 minProtocol: PROTOCOL_VERSION,
                 maxProtocol: PROTOCOL_VERSION,
             });
-            // Race the auth/connect response against the handshakeSettled deferred
+            // Race the network/connect response against the handshakeSettled deferred
             // `raceFirst` (not `race`) — `race` waits for the loser when the
-            // winner fails, so a typed auth/connect error would hang behind the
+            // winner fails, so a typed network/connect error would hang behind the
             // still-pending handshake-watchdog Deferred.
             const result = yield* Effect.raceFirst(authEffect, Deferred.await(handshakeSettled)).pipe(Effect.tap((value) => Effect.sync(() => {
                 this._helloOk = value;
@@ -499,35 +439,20 @@ export class MoltZapWsClient {
             return result;
         });
     }
-    /**
-     * Tracked variant of `sendRpcEffect`. Reuses the same Deferred /
-     * pendingRef plumbing — the only difference is the resolved value:
-     * `{id, result}` instead of bare `result`. This
-     * keeps Invariant 3 (single id source) trivially: we mint `id` once
-     * inside this body, register the Deferred under that id, and return
-     * the same id to the caller alongside the result.
-     */
-    sendRpcTrackedEffect(definition, params, opts) {
+    sendRpcEffect(definition, params, opts) {
         return Effect.gen(this, function* () {
             const method = definition.name;
             const state = yield* Ref.get(this.stateRef);
             if (Option.isNone(state)) {
                 return yield* Effect.fail(makeNotConnectedError());
             }
-            const id = jsonRpcStringId(`rpc-${++this.requestCounter}`);
-            const frame = requestFrame(id, definition, params);
-            // Register the Deferred BEFORE writing. `write` yields to the
-            // scheduler; the reader could interleave, see a close, and
-            // `failAllPending` before we register — leaving us to await a
+            const frame = definition.encodeRequest(`rpc-${++this.requestCounter}`, params);
+            const id = frame.id;
+            // Register the Deferred BEFORE writing — write yields, reader could
+            // close + failAllPending before we register, leaving us awaiting a
             // never-resolved Deferred.
             const deferred = yield* Deferred.make();
             yield* Ref.update(this.pendingRef, (m) => HashMap.set(m, id, deferred));
-            // `socket.writer` gates on an internal Latch that `runRaw` only
-            // opens after the WebSocket hits OPEN. If the socket never
-            // opens, `runRaw`'s `ensuring` closes the latch and `write`
-            // blocks indefinitely — so we race the write against the
-            // pending Deferred (which the reader fails on close),
-            // short-circuiting the dead write.
             const writeAttempt = Effect.either(state.value.write(JSON.stringify(frame)));
             const earlyFailure = Deferred.await(deferred).pipe(Effect.catchAll(() => Effect.succeed(null)), Effect.as(null));
             const writeRace = yield* Effect.race(writeAttempt, earlyFailure);
@@ -549,25 +474,16 @@ export class MoltZapWsClient {
             }), Effect.onExit((exit) => Exit.isFailure(exit)
                 ? Ref.update(this.pendingRef, (m) => HashMap.remove(m, id))
                 : Effect.void));
-            const decodedResult = yield* decodeRpcResult(definition, result).pipe(Effect.mapError(() => new RpcServerError({
-                code: JSON_RPC_INTERNAL_ERROR_CODE,
-                message: `Invalid result for method: ${definition.name}`,
-                data: result,
-            })));
-            return { id, result: decodedResult };
+            if (!definition.validateResult(result)) {
+                return yield* Effect.fail(new RpcServerError({
+                    code: JSON_RPC_INTERNAL_ERROR_CODE,
+                    message: `Invalid result for method: ${definition.name}`,
+                    data: result,
+                }));
+            }
+            return result;
         });
     }
-    /**
-     * Bare-result RPC — projects the tracked RPC envelope onto its
-     * `result` field, discarding the `{id, type}` observability surface.
-     * The write / race / timeout plumbing lives in `sendRpcTrackedEffect`
-     * so there is one shared site for Invariant 3 (single id source),
-     * Invariant 5 (typed error channel), and the `socket.writer` latch
-     * race described below.
-     */
-    sendRpcEffect(definition, params, opts) {
-        return this.sendRpcTrackedEffect(definition, params, opts).pipe(Effect.map((tracked) => tracked.result));
-    }
     /**
      * Translate a typed `OfferRejected` failure from the partitioned
      * dispatcher into a wire-level error response. Spec #356 §5: each
@@ -583,19 +499,15 @@ export class MoltZapWsClient {
     }
     offerRejectedResponse(err, requestId) {
         if (err instanceof PartitionLimitError) {
-            return responseFrame(requestId, {
-                error: {
-                    code: -32000,
-                    message: `Server busy: partition limit reached (${err.activePartitions}/${err.maxPartitions})`,
-                },
+            return encodeErrorResponse(requestId, {
+                code: -32000,
+                message: `Server busy: partition limit reached (${err.activePartitions}/${err.maxPartitions})`,
             });
         }
         if (err instanceof PartitionQueueFullError) {
-            return responseFrame(requestId, {
-                error: {
-                    code: -32000,
-                    message: `Server busy: partition queue full (capacity=${err.capacity})`,
-                },
+            return encodeErrorResponse(requestId, {
+                code: -32000,
+                message: `Server busy: partition queue full (capacity=${err.capacity})`,
             });
         }
         const _exhaustive = err;
@@ -621,11 +533,9 @@ export class MoltZapWsClient {
             const handlers = yield* Ref.get(this.appCallbackHandlersRef);
             const lookup = HashMap.get(handlers, request.definition);
             const buildReply = lookup._tag === "None"
-                ? Effect.succeed(responseFrame(request.id, {
-                    error: {
-                        code: -32601,
-                        message: "No handler registered for app callback descriptor",
-                    },
+                ? Effect.succeed(encodeErrorResponse(request.id, {
+                    code: -32601,
+                    message: "No handler registered for app callback descriptor",
                 }))
                 : lookup
                     .value(request.params, {
@@ -633,20 +543,17 @@ export class MoltZapWsClient {
                     definition: request.definition,
                 })
                     .pipe(Effect.match({
-                    onSuccess: (result) => responseFrame(request.id, {
-                        result,
-                    }),
-                    onFailure: (err) => responseFrame(request.id, {
-                        error: {
-                            code: err.code,
-                            message: err.message,
-                            ...(err.data !== undefined ? { data: err.data } : {}),
-                        },
+                    onSuccess: (result) => request.definition.encodeResponse(request.id, result),
+                    onFailure: (err) => encodeErrorResponse(request.id, {
+                        code: err.code,
+                        message: err.message,
+                        ...(err.data !== undefined ? { data: err.data } : {}),
                     }),
                 }), Effect.catchAllCause((cause) => Effect.sync(() => {
                     this.options.logger?.warn("appCallback handler defected", Cause.pretty(cause));
-                    return responseFrame(request.id, {
-                        error: { code: -32603, message: "Internal error" },
+                    return encodeErrorResponse(request.id, {
+                        code: -32603,
+                        message: "Internal error",
                     });
                 })));
             const reply = yield* buildReply;
@@ -667,8 +574,9 @@ export class MoltZapWsClient {
             if (decodedFrames === null)
                 return;
             for (const decoded of decodedFrames) {
-                if (decoded._tag === "Response") {
-                    const { id, result, error } = decoded;
+                if (decoded._tag === "ResponseSuccess" ||
+                    decoded._tag === "ResponseError") {
+                    const id = decoded.id;
                     const pending = yield* Ref.modify(this.pendingRef, (m) => {
                         const entry = HashMap.get(m, id);
                         return entry._tag === "Some"
@@ -677,7 +585,8 @@ export class MoltZapWsClient {
                     });
                     if (pending === null)
                         continue;
-                    if (error) {
+                    if (decoded._tag === "ResponseError") {
+                        const { error } = decoded;
                         yield* Deferred.fail(pending, new RpcServerError({
                             code: typeof error.code === "number"
                                 ? error.code
@@ -687,7 +596,7 @@ export class MoltZapWsClient {
                         }));
                     }
                     else {
-                        yield* Deferred.succeed(pending, result);
+                        yield* Deferred.succeed(pending, decoded.result);
                     }
                     continue;
                 }
@@ -725,15 +634,9 @@ export class MoltZapWsClient {
                     continue;
                 }
                 if (decoded._tag === "Notification") {
-                    // Spec #222 §5.3: subscribers see the full Raw|Unknown union
-                    // (conformance fuzz exercises both); waiters require a known
-                    // descriptor to key the bucket map.
                     yield* this.subscribers.dispatch(decoded);
-                    if (decoded.definition === undefined)
-                        continue;
-                    const knownDecoded = decoded;
                     const delivered = yield* Ref.modify(this.notificationWaitersRef, (m) => {
-                        const bucket = HashMap.get(m, knownDecoded.definition);
+                        const bucket = HashMap.get(m, decoded.definition);
                         if (bucket._tag === "None" || bucket.value.length === 0) {
                             return [null, m];
                         }
@@ -741,16 +644,16 @@ export class MoltZapWsClient {
                         const chosen = arr[arr.length - 1];
                         const rest = arr.slice(0, -1);
                         const nextMap = rest.length === 0
-                            ? HashMap.remove(m, knownDecoded.definition)
-                            : HashMap.set(m, knownDecoded.definition, rest);
+                            ? HashMap.remove(m, decoded.definition)
+                            : HashMap.set(m, decoded.definition, rest);
                         return [chosen, nextMap];
                     });
                     if (delivered !== null) {
-                        yield* delivered.complete(knownDecoded);
+                        yield* delivered.complete(decoded);
                         continue;
                     }
                     yield* Ref.update(this.notificationsBufferRef, (xs) => {
-                        const appended = [...xs, knownDecoded];
+                        const appended = [...xs, decoded];
                         return appended.length > MAX_EVENT_BUFFER
                             ? appended.slice(-MAX_EVENT_BUFFER)
                             : appended;