@fuzdev/fuz_app 0.9.0 → 0.10.0

package/dist/actions/action_rpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action_rpc.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_rpc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAoB,KAAK,SAAS,EAAC,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAgC,KAAK,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAE9F,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAkC,KAAK,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAS1F;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC7B,+DAA+D;IAC/D,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IAC5B,iDAAiD;IACjD,UAAU,EAAE,gBAAgB,CAAC;IAC7B,8DAA8D;IAC9D,EAAE,EAAE,EAAE,CAAC;IACP,oFAAoF;IACpF,aAAa,EAAE,EAAE,CAAC;IAClB,2EAA2E;IAC3E,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;CACZ;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,CACxD,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,aAAa,KACd,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,aAAa,CAAC;CACvB;AAED,yCAAyC;AACzC,MAAM,WAAW,wBAAwB;IACxC,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;CACZ;AAkDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,wBAAwB,KAAG,KAAK,CAAC,SAAS,CAoOtF,CAAC"}
+{"version":3,"file":"action_rpc.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/action_rpc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,kBAAkB,CAAC;AAChE,OAAO,EAAoB,KAAK,SAAS,EAAC,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAgC,KAAK,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAE9F,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,aAAa,CAAC;AAEpC,OAAO,EAGN,KAAK,gBAAgB,EAGrB,MAAM,oBAAoB,CAAC;AAO5B;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC7B,+DAA+D;IAC/D,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IAC5B,iDAAiD;IACjD,UAAU,EAAE,gBAAgB,CAAC;IAC7B,8DAA8D;IAC9D,EAAE,EAAE,EAAE,CAAC;IACP,oFAAoF;IACpF,aAAa,EAAE,EAAE,CAAC;IAClB,2EAA2E;IAC3E,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;CACZ;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,CAAC,MAAM,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,CACxD,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,aAAa,KACd,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,aAAa,CAAC;CACvB;AAED,yCAAyC;AACzC,MAAM,WAAW,wBAAwB;IACxC,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;CACZ;AAkDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,wBAAwB,KAAG,KAAK,CAAC,SAAS,CAoOtF,CAAC"}

package/dist/actions/action_rpc.js

@@ -17,7 +17,7 @@ import {} from '../http/route_spec.js';
 import { get_request_context, has_role } from '../auth/request_context.js';
 import { CREDENTIAL_TYPE_KEY } from '../hono_context.js';
 import { is_null_schema } from '../http/schema_helpers.js';
-import { JSONRPC_VERSION, JsonrpcRequest } from '../http/jsonrpc.js';
+import { JSONRPC_VERSION, JsonrpcRequest, } from '../http/jsonrpc.js';
 import { jsonrpc_error_messages, jsonrpc_error_code_to_http_status, JSONRPC_ERROR_CODES, } from '../http/jsonrpc_errors.js';
 /**
  * Format a JSON-RPC error response.

package/dist/http/jsonrpc.d.ts

@@ -1,10 +1,9 @@
 /**
- * JSON-RPC 2.0 envelope schemas for the single RPC endpoint dispatcher.
+ * JSON-RPC 2.0 envelope schemas for RPC dispatch and SAES transport.
  *
- * Minimal subset extracted from zzz's `jsonrpc.ts` — only what the
- * `create_rpc_endpoint` dispatcher needs to parse incoming requests
- * and format outgoing responses. Full JSON-RPC schemas (batching,
- * MCP extensions, notification types) remain in zzz.
+ * MCP-superset: includes optional `_meta` and `progressToken` fields
+ * on params and results. These are `optional()` so consumers that
+ * don't use MCP are unaffected.
  *
  * Following MCP, params and result are object-only (no positional arrays).
  *
@@ -20,30 +19,101 @@ export type JsonrpcRequestId = z.infer<typeof JsonrpcRequestId>;
 /** A JSON-RPC method name. */
 export declare const JsonrpcMethod: z.ZodString;
 export type JsonrpcMethod = z.infer<typeof JsonrpcMethod>;
-/** Request params — loose object to allow additional properties. */
-export declare const JsonrpcRequestParams: z.ZodObject<{}, z.core.$loose>;
+/** A progress token, used to associate progress notifications with the original request. */
+export declare const JsonrpcProgressToken: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+export type JsonrpcProgressToken = z.infer<typeof JsonrpcProgressToken>;
+/** MCP metadata object — loose to allow additional properties and `.extend`. */
+export declare const JsonrpcMcpMeta: z.ZodObject<{}, z.core.$loose>;
+export type JsonrpcMcpMeta = z.infer<typeof JsonrpcMcpMeta>;
+/** Request params metadata — extends MCP meta with optional progress token. */
+export declare const JsonrpcRequestParamsMeta: z.ZodObject<{
+    progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$loose>;
+export type JsonrpcRequestParamsMeta = z.infer<typeof JsonrpcRequestParamsMeta>;
+/** Request params — loose object with optional MCP metadata. */
+export declare const JsonrpcRequestParams: z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodObject<{
+        progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
 export type JsonrpcRequestParams = z.infer<typeof JsonrpcRequestParams>;
-/** Result — loose object to allow additional properties. */
-export declare const JsonrpcResult: z.ZodObject<{}, z.core.$loose>;
+/** Notification params — loose object with optional MCP metadata. */
+export declare const JsonrpcNotificationParams: z.ZodObject<{
+    /**
+     * Reserved by MCP to allow clients and servers to attach
+     * additional metadata to their notifications.
+     */
+    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$loose>;
+export type JsonrpcNotificationParams = z.infer<typeof JsonrpcNotificationParams>;
+/** Result — loose object with optional MCP metadata. */
+export declare const JsonrpcResult: z.ZodObject<{
+    /**
+     * Reserved by the protocol to allow clients and servers
+     * to attach additional metadata to their responses.
+     */
+    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$loose>;
 export type JsonrpcResult = z.infer<typeof JsonrpcResult>;
 /** A request that expects a response. */
 export declare const JsonrpcRequest: z.ZodObject<{
     jsonrpc: z.ZodLiteral<"2.0">;
     id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
     method: z.ZodString;
-    params: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{
+            progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type JsonrpcRequest = z.infer<typeof JsonrpcRequest>;
+/** A notification which does not expect a response. */
+export declare const JsonrpcNotification: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        /**
+         * Reserved by MCP to allow clients and servers to attach
+         * additional metadata to their notifications.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type JsonrpcNotification = z.infer<typeof JsonrpcNotification>;
 /** A successful (non-error) response to a request. */
 export declare const JsonrpcResponse: z.ZodObject<{
     jsonrpc: z.ZodLiteral<"2.0">;
     id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    result: z.ZodObject<{}, z.core.$loose>;
+    result: z.ZodObject<{
+        /**
+         * Reserved by the protocol to allow clients and servers
+         * to attach additional metadata to their responses.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
 }, z.core.$loose>;
 export type JsonrpcResponse = z.infer<typeof JsonrpcResponse>;
+export declare const JSONRPC_PARSE_ERROR = -32700;
+export declare const JSONRPC_INVALID_REQUEST = -32600;
+export declare const JSONRPC_METHOD_NOT_FOUND = -32601;
+export declare const JSONRPC_INVALID_PARAMS = -32602;
+export declare const JSONRPC_INTERNAL_ERROR = -32603;
+/** Start of the server-defined error code range (-32000). */
+export declare const JSONRPC_SERVER_ERROR_START = -32000;
+/** End of the server-defined error code range (-32099). */
+export declare const JSONRPC_SERVER_ERROR_END = -32099;
+/** A server-defined error code in the -32000 to -32099 range. */
+export declare const JsonrpcServerErrorCode: z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">;
+export type JsonrpcServerErrorCode = z.infer<typeof JsonrpcServerErrorCode>;
+/**
+ * A valid JSON-RPC error code — one of the 5 standard codes or
+ * a server-defined code in the -32000 to -32099 range.
+ */
+export declare const JsonrpcErrorCode: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
+export type JsonrpcErrorCode = z.infer<typeof JsonrpcErrorCode>;
 /** Error object within a JSON-RPC error response. */
 export declare const JsonrpcErrorObject: z.ZodObject<{
-    code: z.ZodNumber;
+    code: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
     message: z.ZodString;
     data: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$loose>;
@@ -53,10 +123,124 @@ export declare const JsonrpcErrorResponse: z.ZodObject<{
     jsonrpc: z.ZodLiteral<"2.0">;
     id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     error: z.ZodObject<{
-        code: z.ZodNumber;
+        code: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
         message: z.ZodString;
         data: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>;
 }, z.core.$loose>;
 export type JsonrpcErrorResponse = z.infer<typeof JsonrpcErrorResponse>;
+/** A successful response or an error response. */
+export declare const JsonrpcResponseOrError: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        /**
+         * Reserved by the protocol to allow clients and servers
+         * to attach additional metadata to their responses.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    error: z.ZodObject<{
+        code: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>;
+}, z.core.$loose>]>;
+export type JsonrpcResponseOrError = z.infer<typeof JsonrpcResponseOrError>;
+/** Any valid JSON-RPC message (request, notification, response, or error response). */
+export declare const JsonrpcMessage: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{
+            progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        /**
+         * Reserved by MCP to allow clients and servers to attach
+         * additional metadata to their notifications.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        /**
+         * Reserved by the protocol to allow clients and servers
+         * to attach additional metadata to their responses.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    error: z.ZodObject<{
+        code: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>;
+}, z.core.$loose>]>;
+export type JsonrpcMessage = z.infer<typeof JsonrpcMessage>;
+/** Messages a client can send to a server (request or notification). */
+export declare const JsonrpcMessageFromClientToServer: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{
+            progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        /**
+         * Reserved by MCP to allow clients and servers to attach
+         * additional metadata to their notifications.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>]>;
+export type JsonrpcMessageFromClientToServer = z.infer<typeof JsonrpcMessageFromClientToServer>;
+/** Messages a server can send to a client (notification, response, or error response). */
+export declare const JsonrpcMessageFromServerToClient: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        /**
+         * Reserved by MCP to allow clients and servers to attach
+         * additional metadata to their notifications.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        /**
+         * Reserved by the protocol to allow clients and servers
+         * to attach additional metadata to their responses.
+         */
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    error: z.ZodObject<{
+        code: z.ZodUnion<readonly [z.ZodLiteral<-32700>, z.ZodLiteral<-32600>, z.ZodLiteral<-32601>, z.ZodLiteral<-32602>, z.ZodLiteral<-32603>, z.core.$ZodBranded<z.ZodNumber, "JsonrpcServerErrorCode", "out">]>;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>;
+}, z.core.$loose>]>;
+export type JsonrpcMessageFromServerToClient = z.infer<typeof JsonrpcMessageFromServerToClient>;
 //# sourceMappingURL=jsonrpc.d.ts.map

package/dist/http/jsonrpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,iDAAoC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,8BAA8B;AAC9B,eAAO,MAAM,aAAa,aAAa,CAAC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,gCAAoB,CAAC;AACtD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,4DAA4D;AAC5D,eAAO,MAAM,aAAa,gCAAoB,CAAC;AAC/C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,yCAAyC;AACzC,eAAO,MAAM,cAAc;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,sDAAsD;AACtD,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,qDAAqD;AACrD,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,mDAAmD;AACnD,eAAO,MAAM,oBAAoB;;;;;;;;iBAI/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/jsonrpc.ts"],"names":[],"mappings":"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"}

package/dist/http/jsonrpc.js

@@ -1,10 +1,9 @@
 /**
- * JSON-RPC 2.0 envelope schemas for the single RPC endpoint dispatcher.
+ * JSON-RPC 2.0 envelope schemas for RPC dispatch and SAES transport.
  *
- * Minimal subset extracted from zzz's `jsonrpc.ts` — only what the
- * `create_rpc_endpoint` dispatcher needs to parse incoming requests
- * and format outgoing responses. Full JSON-RPC schemas (batching,
- * MCP extensions, notification types) remain in zzz.
+ * MCP-superset: includes optional `_meta` and `progressToken` fields
+ * on params and results. These are `optional()` so consumers that
+ * don't use MCP are unaffected.
  *
  * Following MCP, params and result are object-only (no positional arrays).
  *
@@ -18,10 +17,39 @@ export const JSONRPC_VERSION = '2.0';
 export const JsonrpcRequestId = z.union([z.string(), z.number()]);
 /** A JSON-RPC method name. */
 export const JsonrpcMethod = z.string();
-/** Request params — loose object to allow additional properties. */
-export const JsonrpcRequestParams = z.looseObject({});
-/** Result — loose object to allow additional properties. */
-export const JsonrpcResult = z.looseObject({});
+/** A progress token, used to associate progress notifications with the original request. */
+export const JsonrpcProgressToken = z.union([z.string(), z.number()]);
+/** MCP metadata object — loose to allow additional properties and `.extend`. */
+export const JsonrpcMcpMeta = z.looseObject({});
+/** Request params metadata — extends MCP meta with optional progress token. */
+export const JsonrpcRequestParamsMeta = JsonrpcMcpMeta.extend({
+    /**
+     * If specified, the caller is requesting out-of-band progress notifications
+     * for this request. The value is an opaque token attached to subsequent
+     * notifications. The receiver is not obligated to provide these notifications.
+     */
+    progressToken: JsonrpcProgressToken.optional(),
+});
+/** Request params — loose object with optional MCP metadata. */
+export const JsonrpcRequestParams = z.looseObject({
+    _meta: JsonrpcRequestParamsMeta.optional(),
+});
+/** Notification params — loose object with optional MCP metadata. */
+export const JsonrpcNotificationParams = z.looseObject({
+    /**
+     * Reserved by MCP to allow clients and servers to attach
+     * additional metadata to their notifications.
+     */
+    _meta: JsonrpcMcpMeta.optional(),
+});
+/** Result — loose object with optional MCP metadata. */
+export const JsonrpcResult = z.looseObject({
+    /**
+     * Reserved by the protocol to allow clients and servers
+     * to attach additional metadata to their responses.
+     */
+    _meta: JsonrpcMcpMeta.optional(),
+});
 /** A request that expects a response. */
 export const JsonrpcRequest = z.looseObject({
     jsonrpc: z.literal(JSONRPC_VERSION),
@@ -29,15 +57,50 @@ export const JsonrpcRequest = z.looseObject({
     method: JsonrpcMethod,
     params: JsonrpcRequestParams.optional(),
 });
+/** A notification which does not expect a response. */
+export const JsonrpcNotification = z.looseObject({
+    jsonrpc: z.literal(JSONRPC_VERSION),
+    method: JsonrpcMethod,
+    params: JsonrpcNotificationParams.optional(),
+});
 /** A successful (non-error) response to a request. */
 export const JsonrpcResponse = z.looseObject({
     jsonrpc: z.literal(JSONRPC_VERSION),
     id: JsonrpcRequestId,
     result: JsonrpcResult,
 });
+// --- Error code schemas ---
+// Standard JSON-RPC error codes — https://www.jsonrpc.org/specification
+export const JSONRPC_PARSE_ERROR = -32700;
+export const JSONRPC_INVALID_REQUEST = -32600;
+export const JSONRPC_METHOD_NOT_FOUND = -32601;
+export const JSONRPC_INVALID_PARAMS = -32602;
+export const JSONRPC_INTERNAL_ERROR = -32603;
+/** Start of the server-defined error code range (-32000). */
+export const JSONRPC_SERVER_ERROR_START = -32000;
+/** End of the server-defined error code range (-32099). */
+export const JSONRPC_SERVER_ERROR_END = -32099;
+/** A server-defined error code in the -32000 to -32099 range. */
+export const JsonrpcServerErrorCode = z
+    .number()
+    .gte(JSONRPC_SERVER_ERROR_END)
+    .lte(JSONRPC_SERVER_ERROR_START)
+    .brand('JsonrpcServerErrorCode');
+/**
+ * A valid JSON-RPC error code — one of the 5 standard codes or
+ * a server-defined code in the -32000 to -32099 range.
+ */
+export const JsonrpcErrorCode = z.union([
+    z.literal(JSONRPC_PARSE_ERROR),
+    z.literal(JSONRPC_INVALID_REQUEST),
+    z.literal(JSONRPC_METHOD_NOT_FOUND),
+    z.literal(JSONRPC_INVALID_PARAMS),
+    z.literal(JSONRPC_INTERNAL_ERROR),
+    JsonrpcServerErrorCode,
+]);
 /** Error object within a JSON-RPC error response. */
 export const JsonrpcErrorObject = z.looseObject({
-    code: z.number(),
+    code: JsonrpcErrorCode,
     message: z.string(),
     data: z.unknown().optional(),
 });
@@ -47,3 +110,20 @@ export const JsonrpcErrorResponse = z.looseObject({
     id: JsonrpcRequestId.nullable(),
     error: JsonrpcErrorObject,
 });
+/** A successful response or an error response. */
+export const JsonrpcResponseOrError = z.union([JsonrpcResponse, JsonrpcErrorResponse]);
+/** Any valid JSON-RPC message (request, notification, response, or error response). */
+export const JsonrpcMessage = z.union([
+    JsonrpcRequest,
+    JsonrpcNotification,
+    JsonrpcResponse,
+    JsonrpcErrorResponse,
+]);
+/** Messages a client can send to a server (request or notification). */
+export const JsonrpcMessageFromClientToServer = z.union([JsonrpcRequest, JsonrpcNotification]);
+/** Messages a server can send to a client (notification, response, or error response). */
+export const JsonrpcMessageFromServerToClient = z.union([
+    JsonrpcNotification,
+    JsonrpcResponse,
+    JsonrpcErrorResponse,
+]);

package/dist/http/jsonrpc_errors.d.ts

@@ -3,10 +3,12 @@
  *
  * Provides error types, named constructors, and HTTP status mapping
  * for the throw/catch error pattern used by `apply_route_specs`.
- * Extracted from zzz's `jsonrpc_errors.ts` — only core error codes
- * (5 standard + 8 general application). Domain-specific codes stay
- * in consumers. `JSONRPC_ERROR_CODES` is extensible — consumers
- * add their own codes by casting `as JsonrpcErrorCode`.
+ * Core error codes (5 standard + 8 general application). Domain-specific
+ * codes stay in consumers — add by casting `as JsonrpcErrorCode`.
+ *
+ * `JsonrpcErrorCode` and `JsonrpcErrorObject` types are Zod-inferred
+ * from `jsonrpc.ts` — this module re-uses those as the single source
+ * of truth.
  *
  * Complementary to `error_schemas.ts`: that module is declarative
  * (Zod schemas for surface introspection), this one is runtime
@@ -14,16 +16,7 @@
  *
  * @module
  */
-/** Branded number type for JSON-RPC error codes. */
-export type JsonrpcErrorCode = number & {
-    readonly __brand: 'JsonrpcErrorCode';
-};
-/** JSON-RPC error response object — code, message, and optional data. */
-export interface JsonrpcErrorJson {
-    code: JsonrpcErrorCode;
-    message: string;
-    data?: unknown;
-}
+import { type JsonrpcErrorCode, type JsonrpcErrorObject } from './jsonrpc.js';
 /** Names of standard and general application JSON-RPC error codes. */
 export type JsonrpcErrorName = 'parse_error' | 'invalid_request' | 'method_not_found' | 'invalid_params' | 'internal_error' | 'unauthenticated' | 'forbidden' | 'not_found' | 'conflict' | 'validation_error' | 'rate_limited' | 'service_unavailable' | 'timeout';
 /**
@@ -34,15 +27,10 @@ export type JsonrpcErrorName = 'parse_error' | 'invalid_request' | 'method_not_f
  * -32099 range reserved by the JSON-RPC spec.
  */
 export declare const JSONRPC_ERROR_CODES: {
-    /** -32700 */
     readonly parse_error: JsonrpcErrorCode;
-    /** -32600 */
     readonly invalid_request: JsonrpcErrorCode;
-    /** -32601 */
     readonly method_not_found: JsonrpcErrorCode;
-    /** -32602 */
     readonly invalid_params: JsonrpcErrorCode;
-    /** -32603 */
     readonly internal_error: JsonrpcErrorCode;
     /**
      * Same as HTTP 401 "unauthorized", but correctly named.
@@ -67,26 +55,26 @@ export declare const JSONRPC_ERROR_CODES: {
     readonly timeout: JsonrpcErrorCode;
 };
 /**
- * Named constructors for `JsonrpcErrorJson` objects.
+ * Named constructors for `JsonrpcErrorObject` values.
  *
- * Each function creates a JSON-RPC error response object with the correct
+ * Each function creates a JSON-RPC error object with the correct
  * code and a sensible default message. Used by the catch layer in
  * `apply_route_specs` to build response bodies.
  */
 export declare const jsonrpc_error_messages: {
-    readonly parse_error: (data?: unknown) => JsonrpcErrorJson;
-    readonly invalid_request: (data?: unknown) => JsonrpcErrorJson;
-    readonly method_not_found: (method?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly invalid_params: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly internal_error: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly unauthenticated: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly forbidden: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly not_found: (resource?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly conflict: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly validation_error: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly rate_limited: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly service_unavailable: (message?: string, data?: unknown) => JsonrpcErrorJson;
-    readonly timeout: (message?: string, data?: unknown) => JsonrpcErrorJson;
+    readonly parse_error: (data?: unknown) => JsonrpcErrorObject;
+    readonly invalid_request: (data?: unknown) => JsonrpcErrorObject;
+    readonly method_not_found: (method?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly invalid_params: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly internal_error: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly unauthenticated: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly forbidden: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly not_found: (resource?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly conflict: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly validation_error: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly rate_limited: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly service_unavailable: (message?: string, data?: unknown) => JsonrpcErrorObject;
+    readonly timeout: (message?: string, data?: unknown) => JsonrpcErrorObject;
 };
 /**
  * Error class carrying a JSON-RPC error code — thrown by handlers,
@@ -119,6 +107,21 @@ export declare const jsonrpc_errors: {
     readonly service_unavailable: (message?: string | undefined, data?: unknown) => ThrownJsonrpcError;
     readonly timeout: (message?: string | undefined, data?: unknown) => ThrownJsonrpcError;
 };
+/**
+ * Maps JSON-RPC error codes to HTTP status codes.
+ *
+ * Extensible — consumers with domain-specific error codes can spread
+ * this into their own mapping object.
+ */
+export declare const JSONRPC_ERROR_CODE_TO_HTTP_STATUS: Record<number, number>;
+/**
+ * Maps HTTP status codes to JSON-RPC error codes (reverse mapping).
+ *
+ * When multiple error codes map to the same HTTP status (e.g. parse_error
+ * and invalid_request both map to 400), the last one wins. Use for
+ * best-effort HTTP → JSON-RPC translation.
+ */
+export declare const HTTP_STATUS_TO_JSONRPC_ERROR_CODE: Record<number, JsonrpcErrorCode>;
 /**
  * Map a JSON-RPC error code to an HTTP status code.
  *
@@ -129,4 +132,13 @@ export declare const jsonrpc_errors: {
  * @returns the corresponding HTTP status code
  */
 export declare const jsonrpc_error_code_to_http_status: (code: JsonrpcErrorCode) => number;
+/**
+ * Map an HTTP status code to a JSON-RPC error code.
+ *
+ * Returns `internal_error` (-32603) for unrecognized status codes.
+ *
+ * @param status - the HTTP status code
+ * @returns the corresponding JSON-RPC error code
+ */
+export declare const http_status_to_jsonrpc_error_code: (status: number) => JsonrpcErrorCode;
 //# sourceMappingURL=jsonrpc_errors.d.ts.map

package/dist/http/jsonrpc_errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonrpc_errors.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/jsonrpc_errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,oDAAoD;AACpD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;CAAC,CAAC;AAE/E,yEAAyE;AACzE,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CACf;AAED,sEAAsE;AACtE,MAAM,MAAM,gBAAgB,GACzB,aAAa,GACb,iBAAiB,GACjB,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,UAAU,GACV,kBAAkB,GAClB,cAAc,GACd,qBAAqB,GACrB,SAAS,CAAC;AAEb;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;IAE/B,aAAa;0BACU,gBAAgB;IACvC,aAAa;8BACc,gBAAgB;IAC3C,aAAa;+BACe,gBAAgB;IAC5C,aAAa;6BACa,gBAAgB;IAC1C,aAAa;6BACa,gBAAgB;IAG1C;;;;OAIG;8BACwB,gBAAgB;IAC3C;;;OAGG;wBACkB,gBAAgB;wBAChB,gBAAgB;uBACjB,gBAAgB;IACpC;;;OAGG;+BACyB,gBAAgB;2BACpB,gBAAgB;kCACT,gBAAgB;sBAC5B,gBAAgB;CAC2B,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;kCACb,OAAO,KAAG,gBAAgB;sCAMtB,OAAO,KAAG,gBAAgB;yCAMvB,MAAM,SAAS,OAAO,KAAG,gBAAgB;wCAM1C,MAAM,SAAS,OAAO,KAAG,gBAAgB;wCAO1D,MAAM,SACR,OAAO,KACZ,gBAAgB;yCAMQ,MAAM,SAA6B,OAAO,KAAG,gBAAgB;mCAMnE,MAAM,SAAuB,OAAO,KAAG,gBAAgB;oCAMrD,MAAM,SAAS,OAAO,KAAG,gBAAgB;kCAM5C,MAAM,SAAsB,OAAO,KAAG,gBAAgB;0CAM9C,MAAM,SAA8B,OAAO,KAAG,gBAAgB;sCAMlE,MAAM,SAA0B,OAAO,KAAG,gBAAgB;6CAOxE,MAAM,SACR,OAAO,KACZ,gBAAgB;iCAMA,MAAM,SAAqB,OAAO,KAAG,gBAAgB;CAKe,CAAC;AAEzF;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC5C,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;gBAEH,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY;CAK3F;AAWD;;;;GAIG;AACH,eAAO,MAAM,cAAc;8CAXQ,kBAAkB;kDAAlB,kBAAkB;gFAAlB,kBAAkB;+EAAlB,kBAAkB;+EAAlB,kBAAkB;gFAAlB,kBAAkB;0EAAlB,kBAAkB;2EAAlB,kBAAkB;yEAAlB,kBAAkB;iFAAlB,kBAAkB;6EAAlB,kBAAkB;oFAAlB,kBAAkB;wEAAlB,kBAAkB;CAyBqC,CAAC;AAoB3F;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,gBAAgB,KAAG,MACjB,CAAC"}
+{"version":3,"file":"jsonrpc_errors.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/jsonrpc_errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAMN,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,MAAM,cAAc,CAAC;AAEtB,sEAAsE;AACtE,MAAM,MAAM,gBAAgB,GACzB,aAAa,GACb,iBAAiB,GACjB,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,UAAU,GACV,kBAAkB,GAClB,cAAc,GACd,qBAAqB,GACrB,SAAS,CAAC;AAEb;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;0BAEK,gBAAgB;8BACR,gBAAgB;+BACd,gBAAgB;6BACpB,gBAAgB;6BAChB,gBAAgB;IAG1D;;;;OAIG;8BACwB,gBAAgB;IAC3C;;;OAGG;wBACkB,gBAAgB;wBAChB,gBAAgB;uBACjB,gBAAgB;IACpC;;;OAGG;+BACyB,gBAAgB;2BACpB,gBAAgB;kCACT,gBAAgB;sBAC5B,gBAAgB;CAC2B,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;kCACb,OAAO,KAAG,kBAAkB;sCAMxB,OAAO,KAAG,kBAAkB;yCAMzB,MAAM,SAAS,OAAO,KAAG,kBAAkB;wCAM5C,MAAM,SAAS,OAAO,KAAG,kBAAkB;wCAO5D,MAAM,SACR,OAAO,KACZ,kBAAkB;yCAMM,MAAM,SAA6B,OAAO,KAAG,kBAAkB;mCAMrE,MAAM,SAAuB,OAAO,KAAG,kBAAkB;oCAMvD,MAAM,SAAS,OAAO,KAAG,kBAAkB;kCAM9C,MAAM,SAAsB,OAAO,KAAG,kBAAkB;0CAMhD,MAAM,SAA8B,OAAO,KAAG,kBAAkB;sCAMpE,MAAM,SAA0B,OAAO,KAAG,kBAAkB;6CAO1E,MAAM,SACR,OAAO,KACZ,kBAAkB;iCAMF,MAAM,SAAqB,OAAO,KAAG,kBAAkB;CAKe,CAAC;AAE3F;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC5C,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;gBAEH,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY;CAK3F;AAWD;;;;GAIG;AACH,eAAO,MAAM,cAAc;8CAXQ,kBAAkB;kDAAlB,kBAAkB;gFAAlB,kBAAkB;+EAAlB,kBAAkB;+EAAlB,kBAAkB;gFAAlB,kBAAkB;0EAAlB,kBAAkB;2EAAlB,kBAAkB;yEAAlB,kBAAkB;iFAAlB,kBAAkB;6EAAlB,kBAAkB;oFAAlB,kBAAkB;wEAAlB,kBAAkB;CAyBqC,CAAC;AAI3F;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAcpE,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAMzC,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,gBAAgB,KAAG,MAClB,CAAC;AAE1D;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,GAAI,QAAQ,MAAM,KAAG,gBACa,CAAC"}

package/dist/http/jsonrpc_errors.js

@@ -3,10 +3,12 @@
  *
  * Provides error types, named constructors, and HTTP status mapping
  * for the throw/catch error pattern used by `apply_route_specs`.
- * Extracted from zzz's `jsonrpc_errors.ts` — only core error codes
- * (5 standard + 8 general application). Domain-specific codes stay
- * in consumers. `JSONRPC_ERROR_CODES` is extensible — consumers
- * add their own codes by casting `as JsonrpcErrorCode`.
+ * Core error codes (5 standard + 8 general application). Domain-specific
+ * codes stay in consumers — add by casting `as JsonrpcErrorCode`.
+ *
+ * `JsonrpcErrorCode` and `JsonrpcErrorObject` types are Zod-inferred
+ * from `jsonrpc.ts` — this module re-uses those as the single source
+ * of truth.
  *
  * Complementary to `error_schemas.ts`: that module is declarative
  * (Zod schemas for surface introspection), this one is runtime
@@ -14,6 +16,7 @@
  *
  * @module
  */
+import { JSONRPC_PARSE_ERROR, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_INVALID_PARAMS, JSONRPC_INTERNAL_ERROR, } from './jsonrpc.js';
 /**
  * Standard JSON-RPC error codes (5) plus general application codes (8).
  *
@@ -22,17 +25,12 @@
  * -32099 range reserved by the JSON-RPC spec.
  */
 export const JSONRPC_ERROR_CODES = {
-    // Standard JSON-RPC errors — https://www.jsonrpc.org/specification
-    /** -32700 */
-    parse_error: -32700,
-    /** -32600 */
-    invalid_request: -32600,
-    /** -32601 */
-    method_not_found: -32601,
-    /** -32602 */
-    invalid_params: -32602,
-    /** -32603 */
-    internal_error: -32603,
+    // Standard JSON-RPC errors — values from jsonrpc.ts
+    parse_error: JSONRPC_PARSE_ERROR,
+    invalid_request: JSONRPC_INVALID_REQUEST,
+    method_not_found: JSONRPC_METHOD_NOT_FOUND,
+    invalid_params: JSONRPC_INVALID_PARAMS,
+    internal_error: JSONRPC_INTERNAL_ERROR,
     // General application errors (-32000 to -32099)
     /**
      * Same as HTTP 401 "unauthorized", but correctly named.
@@ -57,9 +55,9 @@ export const JSONRPC_ERROR_CODES = {
     timeout: -32008,
 };
 /**
- * Named constructors for `JsonrpcErrorJson` objects.
+ * Named constructors for `JsonrpcErrorObject` values.
  *
- * Each function creates a JSON-RPC error response object with the correct
+ * Each function creates a JSON-RPC error object with the correct
  * code and a sensible default message. Used by the catch layer in
  * `apply_route_specs` to build response bodies.
  */
@@ -170,21 +168,38 @@ export const jsonrpc_errors = {
     timeout: create_error_thrower(jsonrpc_error_messages.timeout),
 };
 // --- HTTP status mapping ---
-const JSONRPC_ERROR_CODE_HTTP_STATUS = new Map([
-    [-32700, 400], // parse_error
-    [-32600, 400], // invalid_request
-    [-32601, 404], // method_not_found
-    [-32602, 400], // invalid_params
-    [-32603, 500], // internal_error
-    [-32001, 401], // unauthenticated
-    [-32002, 403], // forbidden
-    [-32003, 404], // not_found
-    [-32004, 409], // conflict
-    [-32005, 422], // validation_error
-    [-32006, 429], // rate_limited
-    [-32007, 503], // service_unavailable
-    [-32008, 504], // timeout
-]);
+/**
+ * Maps JSON-RPC error codes to HTTP status codes.
+ *
+ * Extensible — consumers with domain-specific error codes can spread
+ * this into their own mapping object.
+ */
+export const JSONRPC_ERROR_CODE_TO_HTTP_STATUS = {
+    [-32700]: 400, // parse_error
+    [-32600]: 400, // invalid_request
+    [-32601]: 404, // method_not_found
+    [-32602]: 400, // invalid_params
+    [-32603]: 500, // internal_error
+    [-32001]: 401, // unauthenticated
+    [-32002]: 403, // forbidden
+    [-32003]: 404, // not_found
+    [-32004]: 409, // conflict
+    [-32005]: 422, // validation_error
+    [-32006]: 429, // rate_limited
+    [-32007]: 503, // service_unavailable
+    [-32008]: 504, // timeout
+};
+/**
+ * Maps HTTP status codes to JSON-RPC error codes (reverse mapping).
+ *
+ * When multiple error codes map to the same HTTP status (e.g. parse_error
+ * and invalid_request both map to 400), the last one wins. Use for
+ * best-effort HTTP → JSON-RPC translation.
+ */
+export const HTTP_STATUS_TO_JSONRPC_ERROR_CODE = Object.fromEntries(Object.entries(JSONRPC_ERROR_CODE_TO_HTTP_STATUS).map(([code, status]) => [
+    status,
+    Number(code),
+]));
 /**
  * Map a JSON-RPC error code to an HTTP status code.
  *
@@ -194,4 +209,13 @@ const JSONRPC_ERROR_CODE_HTTP_STATUS = new Map([
  * @param code - the JSON-RPC error code
  * @returns the corresponding HTTP status code
  */
-export const jsonrpc_error_code_to_http_status = (code) => JSONRPC_ERROR_CODE_HTTP_STATUS.get(code) ?? 500;
+export const jsonrpc_error_code_to_http_status = (code) => JSONRPC_ERROR_CODE_TO_HTTP_STATUS[code] ?? 500;
+/**
+ * Map an HTTP status code to a JSON-RPC error code.
+ *
+ * Returns `internal_error` (-32603) for unrecognized status codes.
+ *
+ * @param status - the HTTP status code
+ * @returns the corresponding JSON-RPC error code
+ */
+export const http_status_to_jsonrpc_error_code = (status) => HTTP_STATUS_TO_JSONRPC_ERROR_CODE[status] ?? JSONRPC_ERROR_CODES.internal_error;

package/dist/http/jsonrpc_helpers.d.ts

@@ -0,0 +1,56 @@
+/**
+ * JSON-RPC message builders, type guards, and converters.
+ *
+ * Used by the SAES runtime (ActionEvent, ActionPeer, transports) and
+ * the RPC endpoint dispatcher. Complements `jsonrpc.ts` (schemas) and
+ * `jsonrpc_errors.ts` (error infrastructure).
+ *
+ * @module
+ */
+import { type JsonrpcErrorResponse, type JsonrpcMethod, type JsonrpcNotification, type JsonrpcNotificationParams, type JsonrpcRequest, type JsonrpcRequestId, type JsonrpcRequestParams, type JsonrpcResponse, type JsonrpcResult, type JsonrpcMessage, JSONRPC_VERSION } from './jsonrpc.js';
+/** Creates a JSON-RPC request message. */
+export declare const create_jsonrpc_request: (method: JsonrpcMethod, params: JsonrpcRequestParams | undefined, id: JsonrpcRequestId) => JsonrpcRequest;
+/** Creates a JSON-RPC success response message. */
+export declare const create_jsonrpc_response: (id: JsonrpcRequestId, result: JsonrpcResult) => JsonrpcResponse;
+/** Creates a JSON-RPC notification message (no id, no response expected). */
+export declare const create_jsonrpc_notification: (method: JsonrpcMethod, params: JsonrpcNotificationParams | undefined) => JsonrpcNotification;
+/** Creates a JSON-RPC error response message. */
+export declare const create_jsonrpc_error_response: (id: JsonrpcErrorResponse["id"], error: JsonrpcErrorResponse["error"]) => JsonrpcErrorResponse;
+/**
+ * Creates a JSON-RPC error response from any error.
+ * Handles `ThrownJsonrpcError` (preserves code/message/data) and
+ * regular `Error` objects (maps to internal_error, includes stack in DEV).
+ */
+export declare const create_jsonrpc_error_response_from_thrown: (id: JsonrpcRequestId | null, error: unknown) => JsonrpcErrorResponse;
+/** Checks if a value is a valid JSON-RPC request id (string or finite number). */
+export declare const is_jsonrpc_request_id: (id: unknown) => id is JsonrpcRequestId;
+/** Checks if a value is a JSON-RPC object (has `jsonrpc: '2.0'`). */
+export declare const is_jsonrpc_object: (message: unknown) => message is {
+    jsonrpc: typeof JSONRPC_VERSION;
+};
+/** Checks if a value is any valid JSON-RPC message or batch array. */
+export declare const is_jsonrpc_message: (message: unknown) => message is JsonrpcMessage | Array<JsonrpcMessage>;
+/** Checks if a value is a JSON-RPC request (has method + id). */
+export declare const is_jsonrpc_request: (message: unknown) => message is JsonrpcRequest;
+/** Checks if a value is a JSON-RPC notification (has method, no id). */
+export declare const is_jsonrpc_notification: (message: unknown) => message is JsonrpcNotification;
+/** Checks if a value is a JSON-RPC success response (has result + id). */
+export declare const is_jsonrpc_response: (message: unknown) => message is JsonrpcResponse;
+/** Checks if a value is a JSON-RPC error response (has error + id). */
+export declare const is_jsonrpc_error_response: (message: unknown) => message is JsonrpcErrorResponse;
+/**
+ * Extracts a JSON-RPC request id from a message or raw value.
+ * Returns `null` if no valid id can be extracted.
+ */
+export declare const to_jsonrpc_message_id: (message_or_id: unknown) => JsonrpcRequestId | null;
+/**
+ * Normalizes input to JSON-RPC params format.
+ * Returns `undefined` for null/undefined, wraps primitives in `{value}`.
+ */
+export declare const to_jsonrpc_params: (input: unknown) => Record<string, any> | undefined;
+/**
+ * Normalizes output to JSON-RPC result format.
+ * Returns empty object for null/undefined, wraps primitives in `{value}`.
+ */
+export declare const to_jsonrpc_result: (output: unknown) => Record<string, any>;
+//# sourceMappingURL=jsonrpc_helpers.d.ts.map

package/dist/http/jsonrpc_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/http/jsonrpc_helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EACN,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EAEnB,eAAe,EACf,MAAM,cAAc,CAAC;AAKtB,0CAA0C;AAC1C,eAAO,MAAM,sBAAsB,GAClC,QAAQ,aAAa,EACrB,QAAQ,oBAAoB,GAAG,SAAS,EACxC,IAAI,gBAAgB,KAClB,cAUF,CAAC;AAEF,mDAAmD;AACnD,eAAO,MAAM,uBAAuB,GACnC,IAAI,gBAAgB,EACpB,QAAQ,aAAa,KACnB,eAID,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,2BAA2B,GACvC,QAAQ,aAAa,EACrB,QAAQ,yBAAyB,GAAG,SAAS,KAC3C,mBASF,CAAC;AAEF,iDAAiD;AACjD,eAAO,MAAM,6BAA6B,GACzC,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAC9B,OAAO,oBAAoB,CAAC,OAAO,CAAC,KAClC,oBAID,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yCAAyC,GACrD,IAAI,gBAAgB,GAAG,IAAI,EAC3B,OAAO,OAAO,KACZ,oBAyBF,CAAC;AAIF,kFAAkF;AAClF,eAAO,MAAM,qBAAqB,GAAI,IAAI,OAAO,KAAG,EAAE,IAAI,gBAGzD,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,GAAI,SAAS,OAAO,KAAG,OAAO,IAAI;IAAC,OAAO,EAAE,OAAO,eAAe,CAAA;CAInD,CAAC;AAE9C,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,GAC9B,SAAS,OAAO,KACd,OAAO,IAAI,cAAc,GAAG,KAAK,CAAC,cAAc,CAGrB,CAAC;AAE/B,iEAAiE;AACjE,eAAO,MAAM,kBAAkB,GAAI,SAAS,OAAO,KAAG,OAAO,IAAI,cACI,CAAC;AAEtE,wEAAwE;AACxE,eAAO,MAAM,uBAAuB,GAAI,SAAS,OAAO,KAAG,OAAO,IAAI,mBACE,CAAC;AAEzE,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,GAAI,SAAS,OAAO,KAAG,OAAO,IAAI,eACG,CAAC;AAEtE,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,GAAI,SAAS,OAAO,KAAG,OAAO,IAAI,oBACJ,CAAC;AAIrE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,eAAe,OAAO,KAAG,gBAAgB,GAAG,IAOjF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAQxE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAQrE,CAAC"}

package/dist/http/jsonrpc_helpers.js

@@ -0,0 +1,138 @@
+/**
+ * JSON-RPC message builders, type guards, and converters.
+ *
+ * Used by the SAES runtime (ActionEvent, ActionPeer, transports) and
+ * the RPC endpoint dispatcher. Complements `jsonrpc.ts` (schemas) and
+ * `jsonrpc_errors.ts` (error infrastructure).
+ *
+ * @module
+ */
+import { DEV } from 'esm-env';
+import { JSONRPC_VERSION, } from './jsonrpc.js';
+import { ThrownJsonrpcError, JSONRPC_ERROR_CODES } from './jsonrpc_errors.js';
+// --- Message builders ---
+/** Creates a JSON-RPC request message. */
+export const create_jsonrpc_request = (method, params, id) => {
+    const message = {
+        jsonrpc: JSONRPC_VERSION,
+        id,
+        method,
+    };
+    if (params !== undefined) {
+        message.params = params;
+    }
+    return message;
+};
+/** Creates a JSON-RPC success response message. */
+export const create_jsonrpc_response = (id, result) => ({
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result,
+});
+/** Creates a JSON-RPC notification message (no id, no response expected). */
+export const create_jsonrpc_notification = (method, params) => {
+    const message = {
+        jsonrpc: JSONRPC_VERSION,
+        method,
+    };
+    if (params !== undefined) {
+        message.params = params;
+    }
+    return message;
+};
+/** Creates a JSON-RPC error response message. */
+export const create_jsonrpc_error_response = (id, error) => ({
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error,
+});
+/**
+ * Creates a JSON-RPC error response from any error.
+ * Handles `ThrownJsonrpcError` (preserves code/message/data) and
+ * regular `Error` objects (maps to internal_error, includes stack in DEV).
+ */
+export const create_jsonrpc_error_response_from_thrown = (id, error) => {
+    let code = JSONRPC_ERROR_CODES.internal_error;
+    let message = 'internal server error';
+    let data = undefined;
+    if (error instanceof ThrownJsonrpcError) {
+        code = error.code;
+        message = error.message;
+        data = error.data;
+    }
+    else if (error instanceof Error) {
+        if (DEV) {
+            message = error.message;
+            data = { stack: error.stack };
+        }
+    }
+    return {
+        jsonrpc: JSONRPC_VERSION,
+        id,
+        error: {
+            code,
+            message,
+            data,
+        },
+    };
+};
+// --- Type guards ---
+/** Checks if a value is a valid JSON-RPC request id (string or finite number). */
+export const is_jsonrpc_request_id = (id) => {
+    const type = typeof id;
+    return type === 'string' || (type === 'number' && !Number.isNaN(id) && Number.isFinite(id));
+};
+/** Checks if a value is a JSON-RPC object (has `jsonrpc: '2.0'`). */
+export const is_jsonrpc_object = (message) => typeof message === 'object' &&
+    message !== null &&
+    !Array.isArray(message) &&
+    message.jsonrpc === JSONRPC_VERSION;
+/** Checks if a value is any valid JSON-RPC message or batch array. */
+export const is_jsonrpc_message = (message) => Array.isArray(message)
+    ? message.length > 0 && message.every((m) => is_jsonrpc_object(m))
+    : is_jsonrpc_object(message);
+/** Checks if a value is a JSON-RPC request (has method + id). */
+export const is_jsonrpc_request = (message) => is_jsonrpc_object(message) && 'method' in message && 'id' in message;
+/** Checks if a value is a JSON-RPC notification (has method, no id). */
+export const is_jsonrpc_notification = (message) => is_jsonrpc_object(message) && 'method' in message && !('id' in message);
+/** Checks if a value is a JSON-RPC success response (has result + id). */
+export const is_jsonrpc_response = (message) => is_jsonrpc_object(message) && 'result' in message && 'id' in message;
+/** Checks if a value is a JSON-RPC error response (has error + id). */
+export const is_jsonrpc_error_response = (message) => is_jsonrpc_object(message) && 'error' in message && 'id' in message;
+// --- Converters ---
+/**
+ * Extracts a JSON-RPC request id from a message or raw value.
+ * Returns `null` if no valid id can be extracted.
+ */
+export const to_jsonrpc_message_id = (message_or_id) => {
+    if (message_or_id == null)
+        return null;
+    const maybe_id = typeof message_or_id === 'object' ? message_or_id.id : message_or_id;
+    return is_jsonrpc_request_id(maybe_id) ? maybe_id : null;
+};
+/**
+ * Normalizes input to JSON-RPC params format.
+ * Returns `undefined` for null/undefined, wraps primitives in `{value}`.
+ */
+export const to_jsonrpc_params = (input) => {
+    if (input === undefined || input === null) {
+        return undefined;
+    }
+    if (typeof input === 'object' && !Array.isArray(input)) {
+        return input;
+    }
+    return { value: input };
+};
+/**
+ * Normalizes output to JSON-RPC result format.
+ * Returns empty object for null/undefined, wraps primitives in `{value}`.
+ */
+export const to_jsonrpc_result = (output) => {
+    if (output === null || output === undefined) {
+        return {};
+    }
+    if (typeof output === 'object' && !Array.isArray(output)) {
+        return output;
+    }
+    return { value: output };
+};

package/dist/testing/rpc_helpers.d.ts

@@ -1,6 +1,6 @@
 import './assert_dev_env.js';
 import { z } from 'zod';
-import type { JsonrpcErrorCode } from '../http/jsonrpc_errors.js';
+import { type JsonrpcErrorCode } from '../http/jsonrpc.js';
 /**
  * Create a `RequestInit` for a JSON-RPC POST request.
  *

package/dist/testing/rpc_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/rpc_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAW7B,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,QAAQ,MAAM,EACd,SAAS,OAAO,EAChB,KAAI,MAAM,GAAG,MAAe,KAC1B,WAID,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,eAAe,MAAM,EACrB,QAAQ,MAAM,EACd,SAAS,OAAO,EAChB,KAAI,MAAM,GAAG,MAAe,KAC1B,MAMF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GACzC,MAAM,OAAO,EACb,gBAAgB,gBAAgB,KAC9B,IAUF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,GAAI,MAAM,OAAO,EAAE,gBAAgB,CAAC,CAAC,OAAO,KAAG,IAU1F,CAAC"}
+{"version":3,"file":"rpc_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/testing/rpc_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAW7B,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAIN,KAAK,gBAAgB,EACrB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAChC,QAAQ,MAAM,EACd,SAAS,OAAO,EAChB,KAAI,MAAM,GAAG,MAAe,KAC1B,WAID,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,eAAe,MAAM,EACrB,QAAQ,MAAM,EACd,SAAS,OAAO,EAChB,KAAI,MAAM,GAAG,MAAe,KAC1B,MAMF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GACzC,MAAM,OAAO,EACb,gBAAgB,gBAAgB,KAC9B,IAUF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,GAAI,MAAM,OAAO,EAAE,gBAAgB,CAAC,CAAC,OAAO,KAAG,IAU1F,CAAC"}

package/dist/testing/rpc_helpers.js

@@ -8,7 +8,7 @@ import './assert_dev_env.js';
  */
 import { assert } from 'vitest';
 import { z } from 'zod';
-import { JSONRPC_VERSION, JsonrpcErrorResponse, JsonrpcResponse } from '../http/jsonrpc.js';
+import { JSONRPC_VERSION, JsonrpcErrorResponse, JsonrpcResponse, } from '../http/jsonrpc.js';
 /**
  * Create a `RequestInit` for a JSON-RPC POST request.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",