orpc-fn 0.7.0 → 0.9.0

package/src/hono.ts

@@ -1,9 +1,6 @@
 import { Readable, pipeline } from 'node:stream'
 import zlib from 'node:zlib'
-import { SmartCoercionPlugin } from '@orpc/json-schema'
 import type { OpenAPIGeneratorGenerateOptions } from '@orpc/openapi'
-import { OpenAPIHandler } from '@orpc/openapi/fetch'
-import { OpenAPIReferencePlugin } from '@orpc/openapi/plugins'
 import {
 	type AnyRouter,
 	type InferRouterInitialContext,
@@ -12,16 +9,35 @@ import {
 import { RPCHandler } from '@orpc/server/fetch'
 import { BatchHandlerPlugin } from '@orpc/server/plugins'
 import type { StandardHandlerPlugin } from '@orpc/server/standard'
-import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
 import type { Context as HonoContext, Env, Hono } from 'hono'
 import type { StatusCode } from 'hono/utils/http-status'
 import { REQUEST_TIMING, type InvocationTiming } from './timing.js'
 import { isExpectedClientError } from './expected-client-error.js'
-import type { ProcedureFilter } from './mcp.js'
+import { hasTag, type ProcedureFilter } from './meta.js'
+
+export { hasTag, type ProcedureFilter }
 
 /** Per-request timings in ms; `fn()` adds `handler_ms`. Sent as Server-Timing. */
 export type RequestTiming = Record<string, number>
 
+/**
+ * Run `work` and add its duration to `timing[key]` (rounded to 0.01 ms),
+ * whether it resolves or throws: `await timed(context.timing, 'auth_ms', () => getSession(headers))`.
+ */
+export async function timed<T>(
+	timing: RequestTiming,
+	key: string,
+	work: () => T | Promise<T>
+): Promise<T> {
+	const started = performance.now()
+	try {
+		return await work()
+	} finally {
+		timing[key] =
+			(timing[key] ?? 0) + Math.round((performance.now() - started) * 100) / 100
+	}
+}
+
 /** What every request starts with; the default context when `context` is omitted. */
 export type BaseContext = { headers: Headers; timing: RequestTiming }
 
@@ -44,8 +60,34 @@ type ContextOption<E extends Env, R extends AnyRouter> =
 		: { context: ContextFactory<E, R> }
 
 type Path = `/${string}`
+type Handler<C> = {
+	handle(
+		request: Request,
+		options: { prefix: Path; context: C }
+	): Promise<{ matched: boolean; response: Response | undefined }>
+}
 type Plugin<T extends object> = StandardHandlerPlugin<T>
 
+export type OpenApiMountOptions<R extends AnyRouter> = {
+	prefix: Path
+	info?: { title: string; version: string; description?: string }
+	/** Docs page, relative to `prefix` (default '/'); the spec is at `/spec.json`. */
+	docsPath?: Path
+	/** false: serve the REST routes without the docs page and `spec.json`. */
+	docs?: boolean
+	/**
+	 * The procedures to publish (also filters the spec), e.g.
+	 * `hasTag('external')`. Required, so publishing is a choice;
+	 * `() => true` publishes every route.
+	 */
+	filter: ProcedureFilter
+	/** Turn JSON strings back into `Date`s etc. for `z.date()` inputs. */
+	smartCoercion?: boolean
+	/** Extra spec fields, e.g. `components.securitySchemes` and `security`. */
+	spec?: Omit<OpenAPIGeneratorGenerateOptions, 'filter'>
+	plugins?: Plugin<InferRouterInitialContext<R>>[]
+}
+
 export type MountOrpcOptions<
 	E extends Env,
 	R extends AnyRouter
@@ -53,20 +95,12 @@ export type MountOrpcOptions<
 	router: R
 	/** Mount the RPC handler (oRPC's `RPCLink`) here. Omit to skip it. */
 	rpcPrefix?: Path
-	/** Mount the OpenAPI (REST) handler and its Scalar docs here. */
-	openapi?: {
-		prefix: Path
-		info?: { title: string; version: string; description?: string }
-		/** Docs page, relative to `prefix` (default '/'); the spec is at `/spec.json`. */
-		docsPath?: Path
-		/** Only expose matching procedures (also filters the spec). */
-		filter?: ProcedureFilter
-		/** Turn JSON strings back into `Date`s etc. for `z.date()` inputs. */
-		smartCoercion?: boolean
-		/** Extra spec fields, e.g. `components.securitySchemes` and `security`. */
-		spec?: Omit<OpenAPIGeneratorGenerateOptions, 'filter'>
-		plugins?: Plugin<InferRouterInitialContext<R>>[]
-	}
+	/**
+	 * Mount the OpenAPI (REST) handler and its Scalar docs here. Needs the
+	 * optional peers `@orpc/openapi`, `@orpc/json-schema` and `@orpc/zod`,
+	 * loaded on the first request to `prefix`.
+	 */
+	openapi?: OpenApiMountOptions<R>
 	/** Collapse parallel RPC calls into one HTTP request. Default: true (25 calls). */
 	batch?: boolean | { maxSize: number }
 	/** Add a Server-Timing header from the request timing. Default: true */
@@ -79,7 +113,10 @@ export type MountOrpcOptions<
 	compress?: boolean
 	/** SSE keep-alive comments every N ms (default 15000), or false. */
 	sseKeepAlive?: boolean | number
-	/** Extra RPC plugins (e.g. `CORSPlugin`). */
+	/**
+	 * Extra RPC plugins. CORS belongs to Hono's `cors()` on the app, once; a
+	 * cross-origin client with batching needs `x-orpc-batch` in its `allowHeaders`.
+	 */
 	plugins?: Plugin<InferRouterInitialContext<R>>[]
 	/** Rewrite request headers before they reach the context (see `normalizeExpoOrigin`). */
 	normalizeHeaders?: (headers: Headers) => Headers
@@ -93,7 +130,10 @@ export type MountOrpcOptions<
 	 * Hono's `onError` never sees them). Expected client errors are skipped.
 	 */
 	onError?: (error: unknown, request: { url: string; method: string }) => void
-	/** Default: 4xx `ORPCError` or `AbortError`. */
+	/**
+	 * Default: `isExpectedClientError`, which also accepts any error the
+	 * route's `createFn({ isExpectedError })` classified as expected.
+	 */
 	isExpectedError?: (error: unknown) => boolean
 }
 
@@ -233,7 +273,7 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 
 	const mount = (
 		prefix: Path,
-		handler: Pick<RPCHandler<InferRouterInitialContext<R>>, 'handle'>
+		handler: Handler<InferRouterInitialContext<R>>
 	) => {
 		app.use(`${prefix}/*`, async (c, next) => {
 			const timing: RequestTiming = {}
@@ -256,7 +296,7 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 					[REQUEST_TIMING]: invocationTiming
 				} as InferRouterInitialContext<R>
 			})
-			if (!matched) return next()
+			if (!matched || !response) return next()
 			const timed = serverTiming
 				? formatServerTiming(performance.now() - started, {
 						...timing,
@@ -302,14 +342,56 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 
 	if (options.openapi) {
 		const { openapi } = options
-		const filter = openapi.filter ? { filter: openapi.filter } : {}
-		const converters = [new ZodToJsonSchemaConverter()]
-		const plugins: Plugin<InferRouterInitialContext<R>>[] = [
-			...(openapi.plugins ?? [])
-		]
-		if (openapi.smartCoercion) {
-			plugins.push(new SmartCoercionPlugin({ schemaConverters: converters }))
-		}
+		if (typeof openapi.filter !== 'function')
+			throw new TypeError(
+				'orpc-fn: mountOrpc openapi needs a filter; pass () => true to publish every route'
+			)
+		let loading: Promise<Handler<InferRouterInitialContext<R>>> | undefined
+		mount(openapi.prefix, {
+			handle: async (request, handleOptions) => {
+				loading ??= createOpenApiHandler(
+					router,
+					openapi,
+					keepAlive,
+					options.onError ? report : undefined
+				)
+				return (await loading).handle(request, handleOptions)
+			}
+		})
+	}
+}
+
+/** Loads the OpenAPI peers only for apps that mount it. */
+async function createOpenApiHandler<R extends AnyRouter>(
+	router: R,
+	openapi: OpenApiMountOptions<R>,
+	keepAlive: object,
+	report:
+		| ((
+				error: unknown,
+				options: { request: { url: URL; method: string } }
+		  ) => void)
+		| undefined
+): Promise<Handler<InferRouterInitialContext<R>>> {
+	const [
+		{ SmartCoercionPlugin },
+		{ OpenAPIHandler },
+		{ OpenAPIReferencePlugin },
+		{ ZodToJsonSchemaConverter }
+	] = await Promise.all([
+		import('@orpc/json-schema'),
+		import('@orpc/openapi/fetch'),
+		import('@orpc/openapi/plugins'),
+		import('@orpc/zod/zod4')
+	])
+	const converters = [new ZodToJsonSchemaConverter()]
+	const plugins: Plugin<InferRouterInitialContext<R>>[] = [
+		...(openapi.plugins ?? [])
+	]
+	if (openapi.smartCoercion) {
+		plugins.push(new SmartCoercionPlugin({ schemaConverters: converters }))
+	}
+	if (openapi.docs !== false) {
 		plugins.push(
 			new OpenAPIReferencePlugin({
 				docsProvider: 'scalar',
@@ -318,19 +400,16 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 				specGenerateOptions: {
 					info: openapi.info ?? { title: 'API', version: '0.0.0' },
 					servers: [{ url: openapi.prefix }],
-					...filter,
+					filter: openapi.filter,
 					...openapi.spec
 				}
 			})
 		)
-		mount(
-			openapi.prefix,
-			new OpenAPIHandler(router, {
-				...keepAlive,
-				...filter,
-				plugins,
-				interceptors: options.onError ? [orpcOnError(report)] : []
-			})
-		)
 	}
+	return new OpenAPIHandler(router, {
+		...keepAlive,
+		filter: openapi.filter,
+		plugins,
+		interceptors: report ? [orpcOnError(report)] : []
+	})
 }

package/src/index.ts

@@ -2,10 +2,11 @@ export { type BoundCall, createBoundCall } from './bound-call.js'
 export {
 	type CreateFnOptions,
 	createFn,
-	type FnFactory
+	type FnFactory,
+	type RoutePolicyParams,
+	type TestCallExtras
 } from './create-fn.js'
 export { isExpectedClientError } from './expected-client-error.js'
-export { createBoundedEventQueue } from './live/pub-sub.js'
 export {
 	createDefaultLogger,
 	type FnLogger,

package/src/issues.ts

@@ -0,0 +1,35 @@
+/** A Standard Schema issue, as oRPC puts them on `error.data.issues`. */
+export type SchemaIssue = {
+	message: string
+	path?: ReadonlyArray<PropertyKey | { key: PropertyKey }> | undefined
+}
+
+/** `items.0.name: Required`, or the bare message for a root issue. */
+export function formatIssue(issue: SchemaIssue): string {
+	const path = (issue.path ?? [])
+		.map((segment) =>
+			String(typeof segment === 'object' ? segment.key : segment)
+		)
+		.join('.')
+	return path ? `${path}: ${issue.message}` : issue.message
+}
+
+/** The validation issues oRPC attaches to a BAD_REQUEST (`data.issues`). */
+export function issuesOf(error: unknown): SchemaIssue[] {
+	const data =
+		typeof error === 'object' && error !== null
+			? (error as { data?: unknown }).data
+			: undefined
+	const issues =
+		typeof data === 'object' && data !== null
+			? (data as { issues?: unknown }).issues
+			: undefined
+	return Array.isArray(issues)
+		? issues.filter(
+				(issue): issue is SchemaIssue =>
+					typeof issue === 'object' &&
+					issue !== null &&
+					typeof (issue as { message?: unknown }).message === 'string'
+			)
+		: []
+}

package/src/json-schema.ts

@@ -1,6 +1,7 @@
 import type { AnySchema } from '@orpc/contract'
 import { JsonSchemaCoercer } from '@orpc/json-schema'
 import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
+import type { SchemaIssue } from './issues.js'
 
 export type JsonSchema = Record<string, unknown>
 
@@ -16,10 +17,10 @@ export type ToolSchema<TIn = unknown, TOut = TIn> = {
 			value: unknown
 		) =>
 			| { value: TOut; issues?: undefined }
-			| { issues: ReadonlyArray<{ message: string }> }
+			| { issues: ReadonlyArray<SchemaIssue> }
 			| Promise<
 					| { value: TOut; issues?: undefined }
-					| { issues: ReadonlyArray<{ message: string }> }
+					| { issues: ReadonlyArray<SchemaIssue> }
 			  >
 		types?: { input: TIn; output: TOut }
 		jsonSchema: {
@@ -32,11 +33,16 @@ export type ToolSchema<TIn = unknown, TOut = TIn> = {
 const converter = new ZodToJsonSchemaConverter()
 const coercer = new JsonSchemaCoercer()
 
-function toJsonSchema(
+/** Converted on first use: an app building many tools at import pays per tool used. */
+function lazyJsonSchema(
 	schema: AnySchema,
 	strategy: 'input' | 'output'
-): JsonSchema {
-	return converter.convert(schema, { strategy })[1] as JsonSchema
+): () => JsonSchema {
+	let converted: JsonSchema | undefined
+	return () => {
+		converted ??= converter.convert(schema, { strategy })[1] as JsonSchema
+		return converted
+	}
 }
 
 /**
@@ -48,20 +54,20 @@ function toJsonSchema(
  * so values are coerced back before validating.
  */
 export function rawInputSchema<TIn>(schema: AnySchema): ToolSchema<TIn> {
-	const jsonSchema = toJsonSchema(schema, 'input')
+	const jsonSchema = lazyJsonSchema(schema, 'input')
 	return {
 		'~standard': {
 			version: 1,
 			vendor: 'orpc-fn',
 			validate: (value) => {
-				const coerced = coercer.coerce(jsonSchema, value) as TIn
+				const coerced = coercer.coerce(jsonSchema(), value) as TIn
 				const finish = (
 					result: Awaited<ReturnType<AnySchema['~standard']['validate']>>
 				) => (result.issues ? { issues: result.issues } : { value: coerced })
 				const result = schema['~standard'].validate(coerced)
 				return result instanceof Promise ? result.then(finish) : finish(result)
 			},
-			jsonSchema: { input: () => jsonSchema, output: () => jsonSchema }
+			jsonSchema: { input: jsonSchema, output: jsonSchema }
 		}
 	}
 }
@@ -70,13 +76,13 @@ export function rawInputSchema<TIn>(schema: AnySchema): ToolSchema<TIn> {
 export function passThroughOutputSchema<TOut>(
 	schema: AnySchema
 ): ToolSchema<TOut> {
-	const jsonSchema = toJsonSchema(schema, 'output')
+	const jsonSchema = lazyJsonSchema(schema, 'output')
 	return {
 		'~standard': {
 			version: 1,
 			vendor: 'orpc-fn',
 			validate: (value) => ({ value: value as TOut }),
-			jsonSchema: { input: () => jsonSchema, output: () => jsonSchema }
+			jsonSchema: { input: jsonSchema, output: jsonSchema }
 		}
 	}
 }

package/src/live/codec.ts

@@ -20,17 +20,15 @@ export function encodePayload(
 	return JSON.stringify({ [MARKER]: 2, id, json, meta })
 }
 
+/** A comparable serialization of a snapshot; undefined when it holds files. */
+export function snapshotKey(value: unknown): string | undefined {
+	const [json, meta, maps, blobs] = serializer.serialize(value)
+	if (maps.length > 0 || blobs.length > 0) return undefined
+	return JSON.stringify([json, meta])
+}
+
 export function decodePayload(payload: string): unknown {
-	const parsed: unknown = JSON.parse(payload)
-	if (
-		typeof parsed === 'object' &&
-		parsed !== null &&
-		[1, 2].includes(Number((parsed as Record<string, unknown>)[MARKER]))
-	) {
-		const { json, meta } = parsed as { json: unknown; meta: [] }
-		return serializer.deserialize(json, meta)
-	}
-	return parsed
+	return decodeMessage(payload).value
 }
 
 /** IDs distinguish replay/live overlap; legacy payloads remain readable. */
@@ -38,13 +36,17 @@ export function decodeMessage(payload: string): {
 	id: string | undefined
 	value: unknown
 } {
-	const envelope = JSON.parse(payload) as unknown
-	const id =
-		typeof envelope === 'object' &&
-		envelope !== null &&
-		(envelope as Record<string, unknown>)[MARKER] === 2 &&
-		typeof (envelope as Record<string, unknown>).id === 'string'
-			? (envelope as { id: string }).id
-			: undefined
-	return { id, value: decodePayload(payload) }
+	const parsed: unknown = JSON.parse(payload)
+	if (typeof parsed !== 'object' || parsed === null)
+		return { id: undefined, value: parsed }
+	const envelope = parsed as Record<string, unknown>
+	const version = Number(envelope[MARKER])
+	if (version !== 1 && version !== 2) return { id: undefined, value: parsed }
+	return {
+		id:
+			version === 2 && typeof envelope.id === 'string'
+				? envelope.id
+				: undefined,
+		value: serializer.deserialize(envelope.json, envelope.meta as [])
+	}
 }

package/src/live/fn-live.ts

@@ -3,8 +3,7 @@ import { type AnyProcedure, ORPCError } from '@orpc/server'
 import type { ZodType, z } from 'zod'
 import { RAW_INPUT } from '../timing.js'
 import { LIVE_GAP, positiveInteger } from './lifecycle.js'
-import type { FnLogger } from '../logger.js'
-import { errorMessageOf } from '../otel.js'
+import { snapshotKey } from './codec.js'
 import type {
 	FnContext,
 	FnDefinition,
@@ -102,6 +101,11 @@ export type FnLiveConfig<
 		authFn?: AuthFn<TInput, FnContext<TDef, TKey>>
 		/** Batch events arriving within this window into one snapshot update. */
 		coalesceMs?: number
+		/**
+		 * Without a transformer, skip a rerun's snapshot when it serializes the
+		 * same as the last one sent. Default: true.
+		 */
+		skipUnchanged?: boolean
 		/** Maximum events collected in one coalescing batch (default 1000). */
 		maxBatchSize?: number
 		/**
@@ -169,11 +173,6 @@ export type FnLiveReturn<
 		context: FnContext<TDef, TKey>
 	}) => string
 	getPublishChannelName: (event: z.output<TEventSchema>) => string
-	/** @deprecated Prefer the separate required-input resolver methods. */
-	getChannelName: (
-		params: Partial<z.output<TInput>> | Partial<z.output<TEventSchema>>,
-		context?: FnContext<TDef, TKey>
-	) => string
 }
 
 /**
@@ -267,32 +266,6 @@ export interface FnLive<TDef extends FnDefinition> {
 	>
 }
 
-/**
- * Fail a live subscription whose initial snapshot could not be built.
- *
- * An expected client failure - an `ORPCError` with a 4xx status, e.g. the
- * subscribed resource was not found or access was refused - reaches the
- * subscriber unchanged and is NOT logged as a server fault. Only 5xx and
- * unknown failures are logged. Unknown errors are wrapped as
- * `INTERNAL_SERVER_ERROR`.
- */
-export function throwInitialSnapshotError(
-	err: unknown,
-	liveName: string,
-	logger: Pick<FnLogger, 'error'>,
-	/** `createFn`'s `isExpectedError`; default: a 4xx `ORPCError`. */
-	isExpected: (error: unknown) => boolean = (error) =>
-		error instanceof ORPCError && error.status < 500
-): never {
-	if (!isExpected(err)) {
-		logger.error('fnLive initial snapshot failed', {
-			name: liveName,
-			err: errorMessageOf(err)
-		})
-	}
-	throw toSnapshotError(err, liveName)
-}
-
 /** An `ORPCError` passes through; anything else becomes INTERNAL_SERVER_ERROR. */
 function toSnapshotError(
 	err: unknown,
@@ -426,7 +399,6 @@ type RuntimeParams = Record<string, unknown> & {
 	input: Record<string, unknown>
 	context: unknown
 	signal: AbortSignal | undefined
-	logger: FnLogger
 	call: (procedure: AnyProcedure, input: unknown) => Promise<unknown>
 	[RAW_INPUT]: unknown
 }
@@ -441,6 +413,7 @@ type RuntimeLiveConfig = Omit<ChannelOptions, 'name'> & {
 	shouldUpdate?: (params: RuntimeParams & Record<string, unknown>) => unknown
 	coalesceMs?: number
 	maxBatchSize?: number
+	skipUnchanged?: boolean
 	summary?: string
 	description?: string
 }
@@ -556,6 +529,7 @@ export function createFnLive(runtime: {
 							live.reauthorize !== true &&
 							!(await live.reauthorize({
 								input: params.input,
+								context: params.context,
 								ctx: params.context
 							}))
 						)
@@ -587,6 +561,8 @@ export function createFnLive(runtime: {
 						}
 						return validate(live.stateSchema as AnySchema, next)
 					}
+					// What the client last received, to skip a rerun that changed nothing.
+					let sent: string | undefined
 					const applyBatch = live.transformerFn
 						? undefined
 						: async (events: readonly unknown[], previous: unknown) => {
@@ -599,7 +575,14 @@ export function createFnLive(runtime: {
 										(await live.shouldUpdate({ ...params, event, previous }))
 									)
 										invalidated = true
-								return invalidated ? rerun() : undefined
+								if (!invalidated) return undefined
+								const next = await rerun()
+								if (live.skipUnchanged === false) return next
+								sent ??= snapshotKey(previous)
+								const key = snapshotKey(next)
+								if (key !== undefined && key === sent) return undefined
+								sent = key
+								return next
 							}
 
 					yield* streamLiveSnapshots({
@@ -622,7 +605,6 @@ export function createFnLive(runtime: {
 			procedure,
 			subscribe,
 			publish: channel.publish,
-			getChannelName: channel.getChannelName,
 			getSubscriptionChannelName: channel.getSubscriptionChannelName,
 			getPublishChannelName: channel.getPublishChannelName
 		}

package/src/live/index.ts

@@ -5,8 +5,7 @@ export {
 	type FnLivePatch,
 	type FnLiveReturn,
 	fnLivePatch,
-	streamLiveSnapshots,
-	throwInitialSnapshotError
+	streamLiveSnapshots
 } from './fn-live.js'
 export {
 	type InvalidationEvent,
@@ -21,6 +20,7 @@ export {
 	type CreatePubSub,
 	createBoundedEventQueue,
 	type FilterFn,
+	type ListenOptions,
 	type ObjectSchema,
 	type Publisher,
 	type PublisherConfig,

package/src/live/memory.ts

@@ -1,16 +1,26 @@
+import { decodePayload } from './codec.js'
 import type { PubSubTransport, PubSubTransportStats } from './transport.js'
 
+/** One message the memory transport carried, decoded. */
+export type PublishedEvent = { channel: string; event: unknown }
+
 /**
  * In-process transport for tests and single-process development. Delivery is
- * asynchronous (a microtask), like a real broker.
+ * asynchronous (a microtask), like a real broker. It records what was
+ * published, so a test asserts on `published()` instead of mocking a bus.
  */
 export function memoryTransport(): PubSubTransport & {
 	/** Active listeners per channel, for assertions. */
 	listenerCount(channel: string): number
 	stats(): PubSubTransportStats
+	/** Events published so far, oldest first, decoded; optionally on one channel. */
+	published(channel?: string): PublishedEvent[]
+	/** Forget the recorded events. */
+	clearPublished(): void
 } {
 	const listeners = new Map<string, Set<(payload: string) => void>>()
 	const backlogs = new Map<string, { items: string[]; expiresAt: number }>()
+	const log: { channel: string; payload: string }[] = []
 
 	return {
 		async close() {
@@ -19,6 +29,7 @@ export function memoryTransport(): PubSubTransport & {
 		},
 		async publish(messages, backlog) {
 			for (const { channel, payload } of messages) {
+				log.push({ channel, payload })
 				if (backlog) {
 					const current = backlogs.get(channel)
 					const items =
@@ -51,6 +62,16 @@ export function memoryTransport(): PubSubTransport & {
 			}
 		},
 		listenerCount: (channel) => listeners.get(channel)?.size ?? 0,
+		published: (channel) =>
+			log
+				.filter((entry) => channel === undefined || entry.channel === channel)
+				.map((entry) => ({
+					channel: entry.channel,
+					event: decodePayload(entry.payload)
+				})),
+		clearPublished: () => {
+			log.length = 0
+		},
 		stats: () => ({
 			channels: listeners.size,
 			listeners: [...listeners.values()].reduce(