@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/client/index.ts

@@ -1,157 +0,0 @@
-import type { InferRoutes } from "../types.ts"
-import { isClientError } from "./error.ts"
-import type { ClientConfig } from "./http.ts"
-import { HTTPClient } from "./http.ts"
-import type { HoneyClient } from "./types.ts"
-import type { TypedWebSocket } from "./ws.ts"
-import { createTypedWebSocket } from "./ws.ts"
-
-export type { ClientErrorInit } from "./error.ts"
-export {
-	BadGatewayError,
-	BadRequestError,
-	ClientError,
-	ConflictError,
-	ForbiddenError,
-	GatewayTimeoutError,
-	InternalServerError,
-	isClientError,
-	NotFoundError,
-	RateLimitError,
-	ServiceUnavailableError,
-	UnauthorizedError,
-	UnprocessableEntityError,
-} from "./error.ts"
-export { PathParamError } from "./path.ts"
-export type { AuthExpiredContext, ClientConfig, RedirectPolicy, RequestOptions } from "./http.ts"
-export { HTTPClient, newClientRequestId } from "./http.ts"
-import type { SSEEvent } from "./sse.ts"
-
-export type { SSEEvent } from "./sse.ts"
-export { parseSSEStream } from "./sse.ts"
-export type {
-	ClientInput,
-	ClientResult,
-	ErrorEnvelope,
-	ErrorsFor,
-	HoneyClient,
-	InputFor,
-	IsSSE,
-	OutputDefFor,
-	OutputFor,
-	PathsForMethod,
-	ReturnFor,
-} from "./types.ts"
-export type { TypedWebSocket } from "./ws.ts"
-export { createTypedWebSocket } from "./ws.ts"
-
-const HTTP_METHODS = new Set(["delete", "get", "patch", "post", "put"])
-
-function isAsyncIterable(value: unknown): value is AsyncIterable<SSEEvent> {
-	return typeof value === "object" && value !== null && Symbol.asyncIterator in value
-}
-
-export function createClient<T>(config: ClientConfig & { throwOnError: true }): HoneyClient<InferRoutes<T>, true>
-export function createClient<T>(
-	config: Omit<ClientConfig, "throwOnError"> & { throwOnError?: false },
-): HoneyClient<InferRoutes<T>, false>
-export function createClient<T, TThrow extends boolean>(
-	config: ClientConfig & { throwOnError?: TThrow },
-): HoneyClient<InferRoutes<T>, TThrow>
-export function createClient<T, TThrow extends boolean = false>(
-	config: ClientConfig & { throwOnError?: TThrow },
-): HoneyClient<InferRoutes<T>, TThrow> {
-	const http = new HTTPClient(config)
-
-	return new Proxy({} as HoneyClient<InferRoutes<T>, TThrow>, {
-		get(_target, prop: string | symbol) {
-			/* not a thenable, and printable: `await client` and `String(client)` must not hit the method table */
-			if (typeof prop === "symbol" || prop === "then") return undefined
-			if (prop === "toString" || prop === "toJSON") return () => "[object HoneyClient]"
-			if (prop === "$isClientError") return isClientError
-
-			if (prop === "$url") {
-				return (path: string, input?: { params?: Record<string, string>; search?: Record<string, unknown> }) =>
-					http.buildUrl(path, input ?? {})
-			}
-
-			if (prop === "$path") {
-				return (path: string, input?: { params?: Record<string, string>; search?: Record<string, unknown> }) =>
-					http.buildPath(path, input ?? {})
-			}
-
-			if (prop === "ws") {
-				return (
-					path: string,
-					input?: {
-						params?: Record<string, string>
-						protocols?: string | string[]
-						reconnectToken?: string
-						search?: Record<string, unknown>
-					},
-				): TypedWebSocket => {
-					const opts = { params: input?.params, search: input?.search }
-					let url = http.buildWSUrl(path, opts)
-					if (input?.reconnectToken) {
-						const sep = url.includes("?") ? "&" : "?"
-						url = `${url}${sep}reconnect_token=${encodeURIComponent(input.reconnectToken)}`
-					}
-					return createTypedWebSocket(url, { protocols: input?.protocols })
-				}
-			}
-
-			if (HTTP_METHODS.has(prop)) {
-				return (path: string, input?: Record<string, unknown>) => {
-					const method = prop.toUpperCase()
-					const opts = input ?? {}
-					const shouldThrow = config.throwOnError === true
-
-					/**
-					 * One call, one request, consumed either way:
-					 * - `await api.get(...)` sends it; an event-stream response resolves to an
-					 *   `AsyncIterable<SSEEvent>` (never buffered), anything else to the parsed body
-					 *   or result tuple. Returning the call from an async function works the same.
-					 * - `for await (... of api.get(...))` before the call has started sends it as a
-					 *   stream request (`accept: text/event-stream`, no timeout).
-					 * - iterating after awaiting reuses the same response instead of sending again.
-					 */
-					let mode: "auto" | "idle" | "sse" = "idle"
-					let auto: Promise<unknown> | undefined
-					const runAuto = (): Promise<unknown> => {
-						auto ??= http.requestAuto(method, path, opts, shouldThrow)
-						return auto
-					}
-
-					const lazy = new Promise((resolve, reject) => {
-						queueMicrotask(() => {
-							if (mode === "sse") return
-							mode = "auto"
-							runAuto().then(resolve, reject)
-						})
-					})
-					Object.defineProperty(lazy, Symbol.asyncIterator, {
-						value() {
-							if (mode === "idle") {
-								mode = "sse"
-								return http.requestStream(method, path, opts)[Symbol.asyncIterator]()
-							}
-							return (async function* () {
-								const result = await runAuto()
-								if (isAsyncIterable(result)) {
-									yield* result
-									return
-								}
-								const error = (result as { error?: unknown } | null)?.error
-								if (error) throw error instanceof Error ? error : new Error("Request failed")
-								throw new TypeError(`${method} ${path} did not respond with an event stream`)
-							})()
-						},
-					})
-					return lazy
-				}
-			}
-
-			return undefined
-		},
-	})
-}

package/src/client/path.ts

@@ -1,169 +0,0 @@
-/**
- * Client-side path templates. Two spellings are accepted, segment by segment:
- *
- * - Honey route patterns: `:name` (or `:name?`) takes a whole segment, `*name` (or `*`)
- *   takes the rest of the path. Names follow the router grammar, so `:user-id` is one
- *   parameter.
- * - OpenAPI templates: `{name}` anywhere inside a segment (`/ops/{id}:cancel`).
- *
- * Values are percent-encoded. A value that would change the path's shape once a URL parser
- * normalizes it (`""`, `.`, `..`) is rejected, so `{ id: ".." }` can never retarget a request
- * to the parent resource and `{ org: "" }` can never turn `/:org/:repo` into `//repo`.
- */
-
-const BRACE_RE = /\{([^{}/]+)\}/g
-
-export class PathParamError extends Error {
-	constructor(message: string) {
-		super(message)
-		this.name = "PathParamError"
-	}
-}
-
-function own(params: Record<string, unknown>, key: string): unknown {
-	return Object.hasOwn(params, key) ? params[key] : undefined
-}
-
-function toValue(params: Record<string, unknown>, key: string): string | undefined {
-	const raw = own(params, key)
-	if (raw === undefined || raw === null) return undefined
-	return typeof raw === "string" ? raw : String(raw)
-}
-
-function encodeSegmentValue(key: string, value: string): string {
-	if (value === "" || value === "." || value === "..") {
-		throw new PathParamError(
-			`Invalid path param ${JSON.stringify(key)}: ${JSON.stringify(value)} is not a path segment`,
-		)
-	}
-	return encodeURIComponent(value)
-}
-
-/** A wildcard value may span segments; each one is encoded and validated on its own. */
-function encodeWildcardValue(key: string, value: string): string {
-	if (value === "") return ""
-	return value
-		.split("/")
-		.map((part) => encodeSegmentValue(key, part))
-		.join("/")
-}
-
-export function interpolatePath(path: string, params: Record<string, unknown> = {}): string {
-	const segments = path.split("/")
-	const out: string[] = []
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i]
-		if (seg.length > 1 && seg.charCodeAt(0) === 58 /* : */) {
-			const optional = seg.endsWith("?")
-			const name = optional ? seg.slice(1, -1) : seg.slice(1)
-			const value = toValue(params, name)
-			if (value === undefined) {
-				if (optional) continue
-				throw new PathParamError(`Missing path param: ${name}`)
-			}
-			out.push(encodeSegmentValue(name, value))
-			continue
-		}
-		if (seg.charCodeAt(0) === 42 /* * */ && i === segments.length - 1) {
-			const name = seg.length > 1 ? seg.slice(1) : "*"
-			const value = toValue(params, name)
-			if (value === undefined) {
-				if (seg.length === 1) {
-					out.push("")
-					continue
-				}
-				throw new PathParamError(`Missing path param: ${name}`)
-			}
-			out.push(encodeWildcardValue(name, value))
-			continue
-		}
-		out.push(
-			seg.replace(BRACE_RE, (_, name: string) => {
-				const value = toValue(params, name)
-				if (value === undefined) throw new PathParamError(`Missing path param: ${name}`)
-				return encodeSegmentValue(name, value)
-			}),
-		)
-	}
-	return out.join("/")
-}
-
-/** True when the template still has a placeholder in either spelling. */
-export function hasPlaceholder(path: string): boolean {
-	for (const seg of path.split("/")) {
-		if (seg.length > 1 && seg.charCodeAt(0) === 58) return true
-		if (seg.charCodeAt(0) === 42) return true
-		BRACE_RE.lastIndex = 0
-		if (BRACE_RE.test(seg)) return true
-	}
-	return false
-}
-
-/**
- * Substitute the params that are present and leave the others as placeholders. Used for
- * invalidation targets, where a partially resolved target is still a narrower pattern.
- */
-export function interpolatePartial(path: string, params: Record<string, unknown>): string {
-	return path
-		.split("/")
-		.map((seg, i, all) => {
-			if (seg.length > 1 && seg.charCodeAt(0) === 58) {
-				const optional = seg.endsWith("?")
-				const name = optional ? seg.slice(1, -1) : seg.slice(1)
-				const value = toValue(params, name)
-				return value === undefined ? seg : encodeSegmentValue(name, value)
-			}
-			if (seg.charCodeAt(0) === 42 && i === all.length - 1) {
-				const value = toValue(params, seg.length > 1 ? seg.slice(1) : "*")
-				return value === undefined ? seg : encodeWildcardValue(seg.slice(1), value)
-			}
-			return seg.replace(BRACE_RE, (match, name: string) => {
-				const value = toValue(params, name)
-				return value === undefined ? match : encodeSegmentValue(name, value)
-			})
-		})
-		.join("/")
-}
-
-function escapeRegExp(text: string): string {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-const MAX_CACHED_PATTERNS = 1024
-const patternCache = new Map<string, RegExp>()
-
-/** Compile a template to a regex over concrete paths, using the same segment grammar. */
-export function compilePattern(pattern: string): RegExp {
-	let re = patternCache.get(pattern)
-	if (re !== undefined) return re
-	const segments = pattern.split("/")
-	let source = ""
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i]
-		const sep = i === 0 ? "" : "/"
-		if (seg.length > 1 && seg.charCodeAt(0) === 58) {
-			source += seg.endsWith("?") ? `(?:${sep}[^/]+)?` : `${sep}[^/]+`
-			continue
-		}
-		if (seg.charCodeAt(0) === 42 && i === segments.length - 1) {
-			source += `(?:${sep}.*)?`
-			continue
-		}
-		let segSource = ""
-		let last = 0
-		BRACE_RE.lastIndex = 0
-		for (let m = BRACE_RE.exec(seg); m !== null; m = BRACE_RE.exec(seg)) {
-			segSource += `${escapeRegExp(seg.slice(last, m.index))}[^/]+`
-			last = m.index + m[0].length
-		}
-		segSource += escapeRegExp(seg.slice(last))
-		source += sep + segSource
-	}
-	re = new RegExp(`^${source}$`)
-	if (patternCache.size >= MAX_CACHED_PATTERNS) {
-		const oldest = patternCache.keys().next().value
-		if (oldest !== undefined) patternCache.delete(oldest)
-	}
-	patternCache.set(pattern, re)
-	return re
-}

package/src/client/redirect-policy.ts

@@ -1,19 +0,0 @@
-/**
- * Headers a request may carry to another origin when a `redirect: "follow"` client follows a
- * cross-origin redirect. Everything else is dropped on that hop: credentials, the auth header and
- * every header set from config (either form), per call or by an `onRequest` hook, whatever its
- * name. An allowlist, so a header added later never leaks by default.
- *
- * Shared by `createClient` and the generated TypeScript SDK runtime, which embeds this list.
- */
-export const CROSS_ORIGIN_SAFE_HEADERS: readonly string[] = ["accept", "accept-language", "user-agent"]
-
-/** The headers to send on a cross-origin hop: only the allowlisted ones from `headers`. */
-export function crossOriginHeaders(headers: Headers): Headers {
-	const out = new Headers()
-	for (const name of CROSS_ORIGIN_SAFE_HEADERS) {
-		const value = headers.get(name)
-		if (value !== null) out.set(name, value)
-	}
-	return out
-}

package/src/client/sdk.ts

@@ -1,351 +0,0 @@
-import type { ClientConfig, RequestMeta } from "./http.ts"
-import { HTTPClient } from "./http.ts"
-import { compilePattern, hasPlaceholder, interpolatePartial, interpolatePath } from "./path.ts"
-import { createTypedWebSocket } from "./ws.ts"
-
-type ServiceEntry = {
-	invalidate?: readonly string[]
-	method: string
-	params?: readonly string[]
-	path: string
-	sse?: boolean
-	ws?: boolean
-}
-
-type ServiceMapNode = ServiceEntry | { [key: string]: ServiceMapNode }
-type ServiceMap = { [key: string]: ServiceMapNode }
-
-export type InvalidationConfig = {
-	staleTime: number
-}
-
-export type SDKConfig = ClientConfig & {
-	invalidation?: InvalidationConfig
-}
-
-/* bridge generic — Proxy target is object, return type is T (erased at runtime) */
-function bridge<T>(value: object): T {
-	return value as T
-}
-
-function own<T>(record: Record<string, T>, key: string): T | undefined {
-	return Object.hasOwn(record, key) ? record[key] : undefined
-}
-
-/**
- * Resolve invalidation targets by substituting the mutation's params. Params that are absent
- * stay placeholders, so a partially resolved target is a narrower pattern, never dropped:
- * `PUT /orgs/{org}` invalidating `GET /orgs/:org/members/:id` marks `GET /orgs/acme/members/:id`.
- */
-export function resolveInvalidationTargets(
-	targets: readonly string[],
-	params: Record<string, string> | undefined,
-): string[] {
-	const resolved: string[] = []
-	for (const target of targets) {
-		const spaceIdx = target.indexOf(" ")
-		if (spaceIdx === -1 || !params) {
-			resolved.push(target)
-			continue
-		}
-		const targetMethod = target.slice(0, spaceIdx)
-		const targetPath = target.slice(spaceIdx + 1)
-		try {
-			resolved.push(`${targetMethod} ${interpolatePartial(targetPath, params)}`)
-		} catch {
-			/* a param value that is not a path segment cannot address a resource; keep the pattern */
-			resolved.push(target)
-		}
-	}
-	return resolved
-}
-
-/** Test if a concrete path matches a route pattern (`:name`, `{name}`, `*`); literal text is escaped. */
-export function pathMatchesPattern(concretePath: string, pattern: string): boolean {
-	return compilePattern(pattern).test(concretePath)
-}
-
-/* Bound memory: an entry remembers the last N mutations that marked it, and which concrete
-   paths have already refreshed against a pattern-level mark. */
-const MAX_INVALIDATED_BY = 32
-const MAX_REFRESHED = 1024
-
-type StaleEntry = {
-	by: Set<string>
-	/** Concrete paths that have read once since this pattern was marked (pattern entries only). */
-	refreshed?: Set<string>
-	seq: number
-	until: number
-}
-
-/**
- * Stale marks, split by kind so a concrete key is never re-read as a pattern (a path may
- * contain `:`), and a lookup scans only patterns for its own method.
- */
-export class StaleIndex {
-	readonly exact = new Map<string, StaleEntry>()
-	readonly patterns = new Map<string, Map<string, StaleEntry>>()
-
-	mark(target: string, mutation: string, seq: number, until: number): void {
-		const spaceIdx = target.indexOf(" ")
-		const method = target.slice(0, spaceIdx)
-		const path = target.slice(spaceIdx + 1)
-		const isPattern = hasPlaceholder(path)
-		let table: Map<string, StaleEntry>
-		if (isPattern) {
-			table = this.patterns.get(method) ?? new Map()
-			this.patterns.set(method, table)
-		} else {
-			table = this.exact
-		}
-		const existing = table.get(target)
-		if (existing) {
-			existing.by.delete(mutation)
-			existing.by.add(mutation)
-			if (existing.by.size > MAX_INVALIDATED_BY) {
-				const oldest = existing.by.values().next().value
-				if (oldest !== undefined) existing.by.delete(oldest)
-			}
-			existing.until = until
-			existing.seq = seq
-			/* a new mutation re-marks every instance */
-			if (existing.refreshed) existing.refreshed.clear()
-		} else {
-			table.set(target, { by: new Set([mutation]), refreshed: isPattern ? new Set() : undefined, seq, until })
-		}
-	}
-
-	lookup(
-		concreteSelector: string,
-		concretePath: string,
-		method: string,
-		now: number,
-	): { by: string[]; isStale: boolean } {
-		const by = new Set<string>()
-		const exact = this.exact.get(concreteSelector)
-		if (exact) {
-			if (exact.until > now) for (const m of exact.by) by.add(m)
-			else this.exact.delete(concreteSelector)
-		}
-		const table = this.patterns.get(method)
-		if (table) {
-			for (const [key, entry] of table) {
-				if (entry.until <= now) {
-					table.delete(key)
-					continue
-				}
-				if (entry.refreshed?.has(concretePath)) continue
-				if (pathMatchesPattern(concretePath, key.slice(key.indexOf(" ") + 1))) {
-					for (const m of entry.by) by.add(m)
-				}
-			}
-		}
-		return { by: [...by], isStale: by.size > 0 }
-	}
-
-	/**
-	 * A successful stale read clears the mark for that resource only: the exact entry, and this
-	 * concrete path's share of any pattern entry. Marks newer than the read's snapshot stay.
-	 */
-	clear(concreteSelector: string, concretePath: string, method: string, snapshot: number): void {
-		const exact = this.exact.get(concreteSelector)
-		if (exact && exact.seq <= snapshot) this.exact.delete(concreteSelector)
-		const table = this.patterns.get(method)
-		if (!table) return
-		for (const [key, entry] of table) {
-			if (entry.seq > snapshot || !entry.refreshed) continue
-			if (!pathMatchesPattern(concretePath, key.slice(key.indexOf(" ") + 1))) continue
-			if (entry.refreshed.size >= MAX_REFRESHED) {
-				const oldest = entry.refreshed.values().next().value
-				if (oldest !== undefined) entry.refreshed.delete(oldest)
-			}
-			entry.refreshed.add(concretePath)
-		}
-	}
-}
-
-/**
- * Two-tier stale lookup over a flat map (kept for compatibility): exact concrete match, then
- * pattern entries for the same method. Keys are classified by their template placeholders,
- * not by containing `:`. Expired entries are swept.
- */
-export function lookupStale(
-	staleMap: Map<string, { by: string[]; seq: number; until: number }>,
-	concreteSelector: string,
-	concretePath: string,
-	method: string,
-	now: number,
-): { by: string[]; isStale: boolean } {
-	const allBy = new Set<string>()
-	for (const [key, entry] of staleMap) {
-		if (entry.until <= now) {
-			staleMap.delete(key)
-			continue
-		}
-		if (key === concreteSelector) {
-			for (const m of entry.by) allBy.add(m)
-			continue
-		}
-		const spaceIdx = key.indexOf(" ")
-		if (key.slice(0, spaceIdx) !== method) continue
-		const keyPattern = key.slice(spaceIdx + 1)
-		if (hasPlaceholder(keyPattern) && pathMatchesPattern(concretePath, keyPattern)) {
-			for (const m of entry.by) allBy.add(m)
-		}
-	}
-	return { by: [...allBy], isStale: allBy.size > 0 }
-}
-
-function isServiceEntry(node: unknown): node is ServiceEntry {
-	return (
-		typeof node === "object" &&
-		node !== null &&
-		typeof (node as Record<string, unknown>)["method"] === "string" &&
-		typeof (node as Record<string, unknown>)["path"] === "string"
-	)
-}
-
-export function createSDK<T = Record<string, Record<string, (...args: unknown[]) => unknown>>>(
-	serviceMap: ServiceMap,
-	config: SDKConfig,
-): T {
-	const http = new HTTPClient(config)
-	const staleTime = config.invalidation?.staleTime ?? 0
-	const stale = staleTime > 0 ? new StaleIndex() : null
-
-	let invalidationSeq = 0
-
-	const rootCache = new Map<string, object>()
-
-	function buildLeafFn(entry: ServiceEntry, namePath: string[]): Function {
-		/* Paths keep their template; HTTPClient interpolates `{name}` and `:name` alike. */
-		const path = entry.path
-		const method = entry.method
-		let fn: Function
-
-		if (entry.ws) {
-			fn = (input?: Record<string, unknown>) => {
-				const opts = {
-					params: input?.["params"] as Record<string, string> | undefined,
-					search: input?.["search"] as Record<string, unknown> | undefined,
-				}
-				let url = http.buildWSUrl(path, opts)
-				const reconnectToken = input?.["reconnectToken"] as string | undefined
-				if (reconnectToken) {
-					const sep = url.includes("?") ? "&" : "?"
-					url = `${url}${sep}reconnect_token=${encodeURIComponent(reconnectToken)}`
-				}
-				return createTypedWebSocket(url, {
-					protocols: input?.["protocols"] as string | string[] | undefined,
-				})
-			}
-		} else if (entry.sse) {
-			fn = (input?: Record<string, unknown>) => http.requestStream(method, path, input ?? {})
-		} else {
-			fn = async (input?: Record<string, unknown>) => {
-				const opts = input ?? {}
-				const params = opts["params"] as Record<string, string> | undefined
-				const concretePath = interpolatePath(path, params ?? {})
-				const concreteSelector = `${method} ${concretePath}`
-				let requestMeta: RequestMeta | undefined
-
-				if (stale) {
-					const { by, isStale } = stale.lookup(concreteSelector, concretePath, method, Date.now())
-					requestMeta = { invalidatedBy: by, isStale, selector: concreteSelector, seqSnapshot: invalidationSeq }
-				}
-
-				const result =
-					config.throwOnError === true
-						? await http.request(method, path, opts, requestMeta)
-						: await http.requestSafe(method, path, opts, requestMeta)
-
-				if (stale) {
-					const isSuccess =
-						config.throwOnError === true
-							? true
-							: (result as { status: number }).status >= 200 && (result as { status: number }).status < 300
-
-					if (isSuccess) {
-						if (entry.invalidate && entry.invalidate.length > 0) {
-							const seq = ++invalidationSeq
-							const until = Date.now() + staleTime
-							for (const target of resolveInvalidationTargets(entry.invalidate, params)) {
-								stale.mark(target, concreteSelector, seq, until)
-							}
-						}
-
-						if (requestMeta?.isStale) {
-							stale.clear(concreteSelector, concretePath, method, requestMeta.seqSnapshot)
-						}
-					}
-				}
-
-				return result
-			}
-		}
-
-		Object.defineProperty(fn, "name", { value: namePath.join(".") })
-		return fn
-	}
-
-	/** Own keys only: names like `toString` or `constructor` must not resolve through the prototype. */
-	function resolveChild(node: Record<string, unknown>, key: string | symbol, namePath: string[]): unknown {
-		if (typeof key === "symbol" || key === "then") return undefined
-		const child = own(node, key)
-		if (child === undefined) {
-			if (key === "toString" || key === "toJSON")
-				return () => `[object HoneySDK${namePath.length ? ` ${namePath.join(".")}` : ""}]`
-			return undefined
-		}
-		return child
-	}
-
-	function makeNodeProxy(node: ServiceMapNode, namePath: string[]): object {
-		const actionCache = new Map<string, Function>()
-		const childCache = new Map<string, object>()
-		return new Proxy({} as Record<string, unknown>, {
-			get(_, key: string | symbol) {
-				const child = resolveChild(node as Record<string, unknown>, key, namePath)
-				if (child === undefined || typeof child === "function") return child
-				const name = key as string
-
-				if (isServiceEntry(child)) {
-					const cached = actionCache.get(name)
-					if (cached) return cached
-					const fn = buildLeafFn(child, [...namePath, name])
-					actionCache.set(name, fn)
-					return fn
-				}
-
-				const cached = childCache.get(name)
-				if (cached) return cached
-				const childProxy = makeNodeProxy(child as ServiceMapNode, [...namePath, name])
-				childCache.set(name, childProxy)
-				return childProxy
-			},
-		})
-	}
-
-	return bridge<T>(
-		new Proxy(
-			{},
-			{
-				get(_target, key: string | symbol) {
-					const node = resolveChild(serviceMap as Record<string, unknown>, key, [])
-					if (node === undefined || typeof node === "function") return node
-					const name = key as string
-
-					const cached = rootCache.get(name)
-					if (cached) return cached
-
-					const result = isServiceEntry(node)
-						? (buildLeafFn(node, [name]) as unknown as object)
-						: makeNodeProxy(node as ServiceMapNode, [name])
-
-					rootCache.set(name, result)
-					return result
-				},
-			},
-		),
-	)
-}