@emeryld/rrroutes-client 2.2.14 → 2.2.16

package/dist/index.mjs

@@ -26,30 +26,29 @@ var defaultFetcher = async (req) => {
 };
 
 // src/routesV3.client.index.ts
-import { useCallback, useRef } from "react";
+import {
+  buildCacheKey,
+  compilePath,
+  lowProfileParse
+} from "@emeryld/rrroutes-contract";
 import {
   keepPreviousData,
   useInfiniteQuery,
   useMutation,
   useQuery
 } from "@tanstack/react-query";
+import { useCallback, useRef } from "react";
 import { z } from "zod";
-import {
-  buildCacheKey,
-  compilePath
-} from "@emeryld/rrroutes-contract";
 var toUpper = (m) => m.toUpperCase();
-var defaultFeedQuerySchema = z.object({
-  cursor: z.string().optional(),
-  limit: z.coerce.number().min(1).max(100).default(20)
-});
+var paginationQueryShape = {
+  pagination_cursor: z.string().optional(),
+  pagination_limit: z.coerce.number().min(1).max(100).default(20)
+};
+var defaultFeedQuerySchema = z.object(paginationQueryShape);
 var defaultFeedOutputSchema = z.object({
   items: z.array(z.unknown()),
   nextCursor: z.string().optional()
 });
-function zParse(value, schema) {
-  return schema ? schema.parse(value) : value;
-}
 function toSearchString(query) {
   if (!query) return "";
   const params = new URLSearchParams();
@@ -148,41 +147,53 @@ function extractArgs(args) {
 function toArgsTuple(args) {
   return typeof args === "undefined" ? [] : [args];
 }
+function getZodShape(schema) {
+  const shapeOrGetter = schema.shape ? schema.shape : schema._def?.shape?.();
+  if (!shapeOrGetter) return {};
+  return typeof shapeOrGetter === "function" ? shapeOrGetter.call(schema) : shapeOrGetter;
+}
 function augmentFeedQuerySchema(schema) {
   if (!schema) return defaultFeedQuerySchema;
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape ? schema.shape : schema._def?.shape?.();
-    return schema.extend({
-      ...shape ?? {},
-      cursor: defaultFeedQuerySchema.shape.cursor,
-      limit: defaultFeedQuerySchema.shape.limit
-    });
+  if (!(schema instanceof z.ZodObject)) {
+    console.warn(
+      "Feed queries must be a ZodObject; default pagination applied."
+    );
+    return defaultFeedQuerySchema;
   }
-  return z.intersection(schema, defaultFeedQuerySchema);
+  return schema.extend(paginationQueryShape);
 }
 function augmentFeedOutputSchema(schema) {
   if (!schema) return defaultFeedOutputSchema;
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape ? schema.shape : schema._def?.shape?.();
-    const hasItems = Boolean(shape?.items);
-    if (hasItems) return schema.extend({ nextCursor: z.string().optional() });
+  if (schema instanceof z.ZodArray) {
     return z.object({
-      items: z.array(schema),
+      items: schema,
       nextCursor: z.string().optional()
     });
   }
-  if (schema instanceof z.ZodArray) {
+  if (schema instanceof z.ZodObject) {
+    const shape = getZodShape(schema);
+    if (shape?.items) {
+      return schema.extend({
+        nextCursor: z.string().optional()
+      });
+    }
     return z.object({
-      items: schema,
+      items: z.array(schema),
       nextCursor: z.string().optional()
     });
   }
-  return defaultFeedOutputSchema;
+  return z.object({
+    items: z.array(schema),
+    nextCursor: z.string().optional()
+  });
 }
 function buildUrl(leaf, baseUrl, params, query) {
-  const normalizedParams = zParse(params, leaf.cfg.paramsSchema);
-  const normalizedQuery = zParse(query, leaf.cfg.querySchema);
-  const path = compilePath(leaf.path, normalizedParams ?? {});
+  const normalizedParams = leaf.cfg.paramsSchema ? lowProfileParse(leaf.cfg.paramsSchema, params) : {};
+  const normalizedQuery = leaf.cfg.querySchema ? lowProfileParse(leaf.cfg.querySchema, query) : {};
+  const path = compilePath(
+    leaf.path,
+    normalizedParams ?? {}
+  );
   const url = `${baseUrl ?? ""}${path}${toSearchString(normalizedQuery)}`;
   return { url, normalizedQuery, normalizedParams };
 }
@@ -190,10 +201,13 @@ function createRouteClient(opts) {
   const queryClient = opts.queryClient;
   const fetcher = opts.fetcher ?? defaultFetcher;
   const baseUrl = opts.baseUrl;
-  const cursorParam = opts.cursorParam ?? "cursor";
+  const cursorParam = opts.cursorParam ?? "pagination_cursor";
   const getNextCursor = opts.getNextCursor ?? defaultGetNextCursor;
   const environment = opts.environment ?? void 0;
-  const { emit: emitDebug, mode: debugMode } = createDebugEmitter(opts.debug, environment);
+  const { emit: emitDebug, mode: debugMode } = createDebugEmitter(
+    opts.debug,
+    environment
+  );
   const isVerboseDebug = debugMode === "complete";
   const decorateDebugEvent = (event, details) => {
     if (!isVerboseDebug || !details) return event;
@@ -207,11 +221,12 @@ function createRouteClient(opts) {
   function buildInternal(leaf, rqOpts, meta) {
     const isGet = leaf.method === "get";
     const isFeed = !!leaf.cfg.feed;
+    const rawLeafCfg = leaf.cfg;
     const leafCfg = isFeed ? {
-      ...leaf.cfg,
-      querySchema: augmentFeedQuerySchema(leaf.cfg.querySchema),
-      outputSchema: augmentFeedOutputSchema(leaf.cfg.outputSchema)
-    } : leaf.cfg;
+      ...rawLeafCfg,
+      querySchema: augmentFeedQuerySchema(rawLeafCfg.querySchema),
+      outputSchema: augmentFeedOutputSchema(rawLeafCfg.outputSchema)
+    } : rawLeafCfg;
     const method = toUpper(leaf.method);
     const expectsArgs = Boolean(leafCfg.paramsSchema || leafCfg.querySchema);
     const leafLabel = `${leaf.method.toUpperCase()} ${String(leaf.path)}`;
@@ -267,9 +282,13 @@ function createRouteClient(opts) {
       const acceptsBody = Boolean(leafCfg.bodySchema);
       const requiresBody = options?.requireBody ?? (!isGet && acceptsBody);
       if (typeof options?.body !== "undefined") {
-        const normalizedBody = zParse(options.body, leafCfg.bodySchema);
+        const normalizedBody = leafCfg.bodySchema ? lowProfileParse(leafCfg.bodySchema, options.body) : void 0;
         const isMultipart = Array.isArray(leafCfg.bodyFiles) && leafCfg.bodyFiles.length > 0;
-        payload = isMultipart ? toFormData(normalizedBody) : normalizedBody;
+        if (isMultipart && normalizedBody && typeof normalizedBody === "object") {
+          payload = toFormData(normalizedBody);
+        } else {
+          payload = normalizedBody;
+        }
       } else if (requiresBody) {
         throw new Error("Body is required when invoking a mutation fetch.");
       }
@@ -292,7 +311,7 @@ function createRouteClient(opts) {
         const out = await fetcher(
           payload === void 0 ? { url, method } : { url, method, body: payload }
         );
-        const parsed = zParse(out, leafCfg.outputSchema);
+        const parsed = leafCfg.outputSchema ? lowProfileParse(leafCfg.outputSchema, out) : void 0;
         emit(
           decorateDebugEvent(
             {
@@ -303,7 +322,11 @@ function createRouteClient(opts) {
               leaf: leafLabel,
               durationMs: Date.now() - startedAt
             },
-            isVerboseDebug ? { params: normalizedParams, query: normalizedQuery, output: parsed } : void 0
+            isVerboseDebug ? {
+              params: normalizedParams,
+              query: normalizedQuery,
+              output: parsed
+            } : void 0
           )
         );
         options?.onReceive?.(parsed);
@@ -334,7 +357,11 @@ function createRouteClient(opts) {
       const hasBodyCandidate = acceptsBody && tupleLength > maybeBodyIndex;
       const body = hasBodyCandidate ? tupleWithBody[tupleLength - 1] : void 0;
       const tuple = hasBodyCandidate ? tupleWithBody.slice(0, tupleLength - 1) : tupleWithBody;
-      return fetchEndpoint(tuple, { body, onReceive: buildOnReceive, requireBody: false });
+      return fetchEndpoint(tuple, {
+        body,
+        onReceive: buildOnReceive,
+        requireBody: false
+      });
     };
     if (isGet && isFeed) {
       const useEndpoint2 = (...useArgs) => {
@@ -345,13 +372,10 @@ function createRouteClient(opts) {
         const query = args?.query;
         const buildOptions = rqOpts ?? {};
         const listenersRef = useRef(/* @__PURE__ */ new Set());
-        const notifyOnReceive = useCallback(
-          (data) => {
-            buildOptions?.onReceive?.(data);
-            listenersRef.current.forEach((listener) => listener(data));
-          },
-          []
-        );
+        const notifyOnReceive = useCallback((data) => {
+          buildOptions?.onReceive?.(data);
+          listenersRef.current.forEach((listener) => listener(data));
+        }, []);
         const registerOnReceive = useCallback(
           (listener) => {
             listenersRef.current.add(listener);
@@ -367,24 +391,27 @@ function createRouteClient(opts) {
           params,
           query
         );
-        const queryResult = useInfiniteQuery({
-          ...buildOptions,
-          queryKey: getQueryKeys(...tuple),
-          initialPageParam: void 0,
-          getNextPageParam: (lastPage) => getNextCursor(lastPage),
-          placeholderData: keepPreviousData,
-          queryFn: ({ pageParam }) => {
-            const pageQuery = {
-              ...normalizedQuery,
-              ...pageParam ? { [cursorParam]: pageParam } : {}
-            };
-            return fetchEndpoint(tuple, {
-              queryOverride: pageQuery,
-              onReceive: notifyOnReceive
-            });
-          }
-          // NOTE: TData is InfiniteData<T>, so we don't need a select here.
-        }, queryClient);
+        const queryResult = useInfiniteQuery(
+          {
+            ...buildOptions,
+            queryKey: getQueryKeys(...tuple),
+            initialPageParam: void 0,
+            getNextPageParam: (lastPage) => getNextCursor(lastPage),
+            placeholderData: keepPreviousData,
+            queryFn: ({ pageParam }) => {
+              const pageQuery = {
+                ...normalizedQuery,
+                ...pageParam ? { [cursorParam]: pageParam } : {}
+              };
+              return fetchEndpoint(tuple, {
+                queryOverride: pageQuery,
+                onReceive: notifyOnReceive
+              });
+            }
+            // NOTE: TData is InfiniteData<T>, so we don't need a select here.
+          },
+          queryClient
+        );
         return { ...queryResult, onReceive: registerOnReceive };
       };
       return {
@@ -404,13 +431,10 @@ function createRouteClient(opts) {
         const query = args?.query;
         const buildOptions = rqOpts ?? {};
         const listenersRef = useRef(/* @__PURE__ */ new Set());
-        const notifyOnReceive = useCallback(
-          (data) => {
-            buildOptions?.onReceive?.(data);
-            listenersRef.current.forEach((listener) => listener(data));
-          },
-          []
-        );
+        const notifyOnReceive = useCallback((data) => {
+          buildOptions?.onReceive?.(data);
+          listenersRef.current.forEach((listener) => listener(data));
+        }, []);
         const registerOnReceive = useCallback(
           (listener) => {
             listenersRef.current.add(listener);
@@ -421,14 +445,17 @@ function createRouteClient(opts) {
           []
         );
         buildUrl({ ...leaf, cfg: leafCfg }, baseUrl, params, query);
-        const queryResult = useQuery({
-          ...buildOptions,
-          queryKey: getQueryKeys(...tuple),
-          placeholderData: keepPreviousData,
-          queryFn: () => fetchEndpoint(tuple, {
-            onReceive: notifyOnReceive
-          })
-        }, queryClient);
+        const queryResult = useQuery(
+          {
+            ...buildOptions,
+            queryKey: getQueryKeys(...tuple),
+            placeholderData: keepPreviousData,
+            queryFn: () => fetchEndpoint(tuple, {
+              onReceive: notifyOnReceive
+            })
+          },
+          queryClient
+        );
         return { ...queryResult, onReceive: registerOnReceive };
       };
       return {
@@ -462,21 +489,29 @@ function createRouteClient(opts) {
       const notifyListeners = useCallback((data) => {
         listenersRef.current.forEach((listener) => listener(data));
       }, []);
-      const registerOnReceive = useCallback((listener) => {
-        listenersRef.current.add(listener);
-        return () => {
-          listenersRef.current.delete(listener);
-        };
-      }, []);
-      const mutationResult = useMutation({
-        ...mutationBuildOptions,
-        mutationKey: getQueryKeys(...tuple),
-        mutationFn: async (body) => {
-          const result = await fetchMutation(...[...tuple, body]);
-          notifyListeners(result);
-          return result;
-        }
-      }, queryClient);
+      const registerOnReceive = useCallback(
+        (listener) => {
+          listenersRef.current.add(listener);
+          return () => {
+            listenersRef.current.delete(listener);
+          };
+        },
+        []
+      );
+      const mutationResult = useMutation(
+        {
+          ...mutationBuildOptions,
+          mutationKey: getQueryKeys(...tuple),
+          mutationFn: async (body) => {
+            const result = await fetchMutation(
+              ...[...tuple, body]
+            );
+            notifyListeners(result);
+            return result;
+          }
+        },
+        queryClient
+      );
       return { ...mutationResult, onReceive: registerOnReceive };
     };
     return {
@@ -487,25 +522,163 @@ function createRouteClient(opts) {
       fetch: fetchMutation
     };
   }
+  const fetchRaw = async (input) => {
+    const { path, method, query, body, params } = input;
+    if (!path || typeof path !== "string") {
+      throw new Error("fetch(path, ...) requires a non-empty string path.");
+    }
+    if (!method) {
+      throw new Error("fetch(path, method, ...) requires an HTTP method.");
+    }
+    const methodLower = String(method).toLowerCase();
+    const methodUpper = toUpper(methodLower);
+    const flatQuery = normalizeFlatQuery(query);
+    const search = toSearchString(flatQuery);
+    const compiledPath = compileRawPath(path, params);
+    const url = `${baseUrl ?? ""}${compiledPath}${search}`;
+    const leafLabel = `${methodUpper} ${path}`;
+    const startedAt = Date.now();
+    const detail = isVerboseDebug ? { params, query: flatQuery } : void 0;
+    emitDebug(
+      decorateDebugEvent(
+        {
+          type: "fetch",
+          stage: "start",
+          method: methodUpper,
+          url,
+          leaf: leafLabel,
+          ...body !== void 0 ? { body } : {}
+        },
+        detail
+      )
+    );
+    try {
+      const out = await fetcher(
+        body === void 0 ? { url, method: methodUpper } : { url, method: methodUpper, body }
+      );
+      emitDebug(
+        decorateDebugEvent(
+          {
+            type: "fetch",
+            stage: "success",
+            method: methodUpper,
+            url,
+            leaf: leafLabel,
+            durationMs: Date.now() - startedAt
+          },
+          isVerboseDebug ? { params, query: flatQuery, output: out } : void 0
+        )
+      );
+      return out;
+    } catch (error) {
+      emitDebug(
+        decorateDebugEvent(
+          {
+            type: "fetch",
+            stage: "error",
+            method: methodUpper,
+            url,
+            leaf: leafLabel,
+            durationMs: Date.now() - startedAt,
+            ...body !== void 0 ? { body } : {},
+            error
+          },
+          detail
+        )
+      );
+      throw error;
+    }
+  };
   return {
     queryClient,
     invalidate,
+    fetch: fetchRaw,
     build: buildInternal
   };
 }
 function buildRouter(routeClient, routes) {
   const buildLeaf = routeClient.build;
-  return ((key, opts, meta) => buildLeaf(routes[key], opts, meta));
+  return ((key, opts, meta) => buildLeaf(
+    routes[key],
+    opts,
+    meta
+  ));
 }
 function toFormData(body) {
   const fd = new FormData();
   for (const [k, v] of Object.entries(body ?? {})) {
     if (v == null) continue;
-    if (Array.isArray(v)) v.forEach((item, i) => fd.append(`${k}[${i}]`, item));
+    if (Array.isArray(v))
+      v.forEach((item, i) => fd.append(`${k}[${i}]`, item));
     else fd.append(k, v);
   }
   return fd;
 }
+function getPathParamNames(path) {
+  const names = /* @__PURE__ */ new Set();
+  const re = /:([A-Za-z0-9_]+)/g;
+  let match;
+  while ((match = re.exec(path)) !== null) {
+    names.add(match[1]);
+  }
+  return names;
+}
+function normalizeFlatQuery(query) {
+  if (query == null) return void 0;
+  if (typeof query !== "object" || Array.isArray(query)) {
+    throw new Error("Query must be a plain object (Record<string, string>).");
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(query)) {
+    if (v == null) continue;
+    if (typeof v !== "string") {
+      throw new Error(
+        `Query param "${k}" must be a string; received type "${typeof v}".`
+      );
+    }
+    result[k] = v;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function compileRawPath(path, params) {
+  const placeholders = getPathParamNames(path);
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    if (placeholders.size > 0) {
+      throw new Error(
+        `Missing path parameters for "${path}": ${[...placeholders].join(
+          ", "
+        )}`
+      );
+    }
+    return path;
+  }
+  const paramObj = params;
+  const providedNames = new Set(Object.keys(paramObj));
+  for (const name of providedNames) {
+    if (!placeholders.has(name)) {
+      throw new Error(
+        `Unexpected path parameter "${name}" for template "${path}".`
+      );
+    }
+    const value = paramObj[name];
+    if (value != null && (typeof value === "object" || Array.isArray(value))) {
+      throw new Error(
+        `Path parameter "${name}" must be a primitive; received "${typeof value}".`
+      );
+    }
+  }
+  for (const name of placeholders) {
+    if (!providedNames.has(name)) {
+      throw new Error(
+        `Missing value for path parameter "${name}" in template "${path}".`
+      );
+    }
+  }
+  if (placeholders.size === 0) {
+    return path;
+  }
+  return compilePath(path, paramObj);
+}
 
 // src/sockets/socket.client.sys.ts
 import { z as z2 } from "zod";
@@ -764,7 +937,21 @@ function roomsFromData(data, toRooms) {
   if (data == null) return { rooms: [] };
   let state = { rooms: [] };
   const add = (input) => {
-    state = mergeRoomState(state, toRooms(input));
+    const mergeForValue = (value) => {
+      state = mergeRoomState(state, toRooms(value));
+    };
+    if (Array.isArray(input)) {
+      input.forEach((entry) => mergeForValue(entry));
+      return;
+    }
+    if (input && typeof input === "object") {
+      const maybeItems = input.items;
+      if (Array.isArray(maybeItems)) {
+        maybeItems.forEach((entry) => mergeForValue(entry));
+        return;
+      }
+    }
+    mergeForValue(input);
   };
   const maybePages = data?.pages;
   if (Array.isArray(maybePages)) {
@@ -778,22 +965,34 @@ function buildSocketedRoute(options) {
   const { built, toRooms, applySocket, useSocketClient: useSocketClient2 } = options;
   return (...useArgs) => {
     const client = useSocketClient2();
-    const endpointResult = built.useEndpoint(...useArgs);
+    const endpointResult = built.useEndpoint(
+      ...useArgs
+    );
     const argsKey = useMemo2(() => JSON.stringify(useArgs[0] ?? null), [useArgs]);
     const [roomState, setRoomState] = useState2(
       () => roomsFromData(endpointResult.data, toRooms)
     );
     const roomsKey = useMemo2(() => roomState.rooms.join("|"), [roomState.rooms]);
-    const joinMetaKey = useMemo2(() => JSON.stringify(roomState.joinMeta ?? null), [roomState.joinMeta]);
-    const leaveMetaKey = useMemo2(() => JSON.stringify(roomState.leaveMeta ?? null), [roomState.leaveMeta]);
+    const joinMetaKey = useMemo2(
+      () => JSON.stringify(roomState.joinMeta ?? null),
+      [roomState.joinMeta]
+    );
+    const leaveMetaKey = useMemo2(
+      () => JSON.stringify(roomState.leaveMeta ?? null),
+      [roomState.leaveMeta]
+    );
     useEffect2(() => {
       const unsubscribe = endpointResult.onReceive((data) => {
-        setRoomState((prev) => mergeRoomState(prev, toRooms(data)));
+        setRoomState(
+          (prev) => mergeRoomState(prev, toRooms(data))
+        );
       });
       return unsubscribe;
     }, [endpointResult, toRooms]);
     useEffect2(() => {
-      setRoomState(roomsFromData(endpointResult.data, toRooms));
+      setRoomState(
+        roomsFromData(endpointResult.data, toRooms)
+      );
     }, [endpointResult.data, toRooms]);
     useEffect2(() => {
       if (roomState.rooms.length === 0) return;
@@ -812,7 +1011,14 @@ function buildSocketedRoute(options) {
         void client.leaveRooms(roomState.rooms, leaveMeta).catch(() => {
         });
       };
-    }, [client, roomsKey, roomState.joinMeta, roomState.leaveMeta, joinMetaKey, leaveMetaKey]);
+    }, [
+      client,
+      roomsKey,
+      roomState.joinMeta,
+      roomState.leaveMeta,
+      joinMetaKey,
+      leaveMetaKey
+    ]);
     useEffect2(() => {
       const entries = Object.entries(applySocket).filter(
         ([_event, fn]) => typeof fn === "function"
@@ -821,7 +1027,9 @@ function buildSocketedRoute(options) {
         ([ev, fn]) => client.on(ev, (payload, meta) => {
           built.setData((prev) => {
             const next = fn(prev, payload, meta);
-            setRoomState(roomsFromData(next, toRooms));
+            setRoomState(
+              roomsFromData(next, toRooms)
+            );
             return next;
           }, ...useArgs);
         })
@@ -870,7 +1078,11 @@ var SocketClient = class {
     }
     this.onConnect = async () => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "connect_event", err: "Socket is null" });
+        this.dbg({
+          type: "connection",
+          phase: "connect_event",
+          err: "Socket is null"
+        });
         throw new Error("Socket is null in onConnect handler");
       }
       this.dbg({
@@ -889,7 +1101,11 @@ var SocketClient = class {
     };
     this.onReconnect = async (attempt) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "reconnect_event", err: "Socket is null" });
+        this.dbg({
+          type: "connection",
+          phase: "reconnect_event",
+          err: "Socket is null"
+        });
         throw new Error("Socket is null in onReconnect handler");
       }
       this.dbg({
@@ -910,7 +1126,11 @@ var SocketClient = class {
     };
     this.onDisconnect = async (reason) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "disconnect_event", err: "Socket is null" });
+        this.dbg({
+          type: "connection",
+          phase: "disconnect_event",
+          err: "Socket is null"
+        });
         throw new Error("Socket is null in onDisconnect handler");
       }
       this.dbg({
@@ -930,7 +1150,11 @@ var SocketClient = class {
     };
     this.onConnectError = async (err) => {
       if (!this.socket) {
-        this.dbg({ type: "connection", phase: "connect_error_event", err: "Socket is null" });
+        this.dbg({
+          type: "connection",
+          phase: "connect_error_event",
+          err: "Socket is null"
+        });
         throw new Error("Socket is null in onConnectError handler");
       }
       this.dbg({
@@ -948,7 +1172,11 @@ var SocketClient = class {
     };
     this.onPong = async (raw) => {
       if (!this.socket) {
-        this.dbg({ type: "heartbeat", phase: "pong_recv", err: "Socket is null" });
+        this.dbg({
+          type: "heartbeat",
+          phase: "pong_recv",
+          err: "Socket is null"
+        });
         throw new Error("Socket is null in onPong handler");
       }
       const parsed = this.config.pongPayload.safeParse(raw);
@@ -1048,11 +1276,15 @@ var SocketClient = class {
   }
   /** internal stats snapshot */
   stats() {
-    const rooms = Array.from(this.roomCounts.entries()).map(([room, count]) => ({ room, count }));
-    const handlers = Array.from(this.handlerMap.entries()).map(([event, set]) => ({
-      event,
-      handlers: set.size
-    }));
+    const rooms = Array.from(this.roomCounts.entries()).map(
+      ([room, count]) => ({ room, count })
+    );
+    const handlers = Array.from(this.handlerMap.entries()).map(
+      ([event, set]) => ({
+        event,
+        handlers: set.size
+      })
+    );
     return {
       roomsCount: rooms.length,
       totalHandlers: handlers.reduce((a, b) => a + b.handlers, 0),
@@ -1124,7 +1356,10 @@ var SocketClient = class {
           details: this.getValidationDetails(check.error)
         });
         if (this.environment === "development") {
-          console.warn("[socket] ping schema validation failed", check.error.issues);
+          console.warn(
+            "[socket] ping schema validation failed",
+            check.error.issues
+          );
         }
         return;
       }
@@ -1183,7 +1418,12 @@ var SocketClient = class {
   }
   async joinRooms(rooms, meta) {
     if (!this.socket) {
-      this.dbg({ type: "room", phase: "join", rooms: this.toArray(rooms), err: "Socket is null" });
+      this.dbg({
+        type: "room",
+        phase: "join",
+        rooms: this.toArray(rooms),
+        err: "Socket is null"
+      });
       throw new Error("Socket is null in joinRooms method");
     }
     if (!await this.getSysEvent("sys:room_join")({
@@ -1236,7 +1476,12 @@ var SocketClient = class {
   }
   async leaveRooms(rooms, meta) {
     if (!this.socket) {
-      this.dbg({ type: "room", phase: "leave", rooms: this.toArray(rooms), err: "Socket is null" });
+      this.dbg({
+        type: "room",
+        phase: "leave",
+        rooms: this.toArray(rooms),
+        err: "Socket is null"
+      });
       throw new Error("Socket is null in leaveRooms method");
     }
     if (!await this.getSysEvent("sys:room_leave")({
@@ -1288,7 +1533,12 @@ var SocketClient = class {
     const schema = this.events[event].message;
     this.dbg({ type: "register", phase: "register", event });
     if (!this.socket) {
-      this.dbg({ type: "register", phase: "register", event, err: "Socket is null" });
+      this.dbg({
+        type: "register",
+        phase: "register",
+        event,
+        err: "Socket is null"
+      });
       return () => {
       };
     }