@lovrozagar/honey 0.1.0 → 0.2.0

package/src/client/index.ts

@@ -30,9 +30,7 @@ export { createTypedWebSocket } from "./ws.ts"
 
 const HTTP_METHODS = new Set(["delete", "get", "patch", "post", "put"])
 
-export function createClient<T>(
-	config: ClientConfig & { throwOnError: true },
-): HoneyClient<InferRoutes<T>, true>
+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>
@@ -49,17 +47,13 @@ export function createClient<T, TThrow extends boolean = false>(
 			if (prop === "$isClientError") return isClientError
 
 			if (prop === "$url") {
-				return (
-					path: string,
-					input?: { params?: Record<string, string>; search?: Record<string, unknown> },
-				) => http.buildUrl(path, input ?? {})
+				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 ?? {})
+				return (path: string, input?: { params?: Record<string, string>; search?: Record<string, unknown> }) =>
+					http.buildPath(path, input ?? {})
 			}
 
 			if (prop === "ws") {
@@ -97,9 +91,7 @@ export function createClient<T, TThrow extends boolean = false>(
 					let restPromise: Promise<unknown> | undefined
 					const lazyRest = (): Promise<unknown> => {
 						if (!restPromise) {
-							restPromise = shouldThrow
-								? http.request(method, path, opts)
-								: http.requestSafe(method, path, opts)
+							restPromise = shouldThrow ? http.request(method, path, opts) : http.requestSafe(method, path, opts)
 						}
 						return restPromise
 					}

package/src/client/sdk.ts

@@ -39,14 +39,20 @@ export function resolveInvalidationTargets(
 ): string[] {
 	const resolved: string[] = []
 	for (const target of targets) {
-		if (!params || !target.includes(":")) { resolved.push(target); continue }
+		if (!params || !target.includes(":")) {
+			resolved.push(target)
+			continue
+		}
 		const spaceIdx = target.indexOf(" ")
 		const targetMethod = target.slice(0, spaceIdx)
 		const targetPath = target.slice(spaceIdx + 1)
 		let hasUnresolved = false
 		const replaced = targetPath.replace(/:(\w+)/g, (match, key: string) => {
 			const val = params[key]
-			if (val === undefined) { hasUnresolved = true; return match }
+			if (val === undefined) {
+				hasUnresolved = true
+				return match
+			}
 			return encodeURIComponent(val)
 		})
 		if (hasUnresolved) continue
@@ -64,9 +70,7 @@ export function pathMatchesPattern(concretePath: string, pattern: string): boole
 	if (!re) {
 		/* split on :param placeholders, escape each literal segment's metachars, rejoin with [^/]+ */
 		const parts = pattern.split(/:[^/]+/g)
-		const escaped = parts
-			.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-			.join("[^/]+")
+		const escaped = parts.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^/]+")
 		re = new RegExp(`^${escaped}$`)
 		patternRegexCache.set(pattern, re)
 	}
@@ -75,12 +79,12 @@ export function pathMatchesPattern(concretePath: string, pattern: string): boole
 
 /* two-tier stale lookup: exact concrete match, then pattern fallback; sweeps expired entries in one pass */
 export function lookupStale(
-	staleMap: Map<string, { by: string[], seq: number, until: number }>,
+	staleMap: Map<string, { by: string[]; seq: number; until: number }>,
 	concreteSelector: string,
 	concretePath: string,
 	method: string,
 	now: number,
-): { by: string[], isStale: boolean } {
+): { by: string[]; isStale: boolean } {
 	const allBy: string[] = []
 	const expired: string[] = []
 
@@ -89,7 +93,10 @@ export function lookupStale(
 	else if (exact) expired.push(concreteSelector)
 
 	for (const [key, entry] of staleMap) {
-		if (entry.until <= now) { expired.push(key); continue }
+		if (entry.until <= now) {
+			expired.push(key)
+			continue
+		}
 		if (!key.includes(":")) continue
 		const spaceIdx = key.indexOf(" ")
 		const keyMethod = key.slice(0, spaceIdx)
@@ -111,9 +118,7 @@ export function createSDK<T = Record<string, Record<string, (...args: unknown[])
 	const http = new HTTPClient(config)
 	const staleTime = config.invalidation?.staleTime ?? 0
 	const hasInvalidation = staleTime > 0
-	const staleUntil = hasInvalidation
-		? new Map<string, { by: string[], seq: number, until: number }>()
-		: null
+	const staleUntil = hasInvalidation ? new Map<string, { by: string[]; seq: number; until: number }>() : null
 
 	let invalidationSeq = 0
 
@@ -156,14 +161,16 @@ export function createSDK<T = Record<string, Record<string, (...args: unknown[])
 					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)
+				const result =
+					config.throwOnError === true
+						? await http.request(method, path, opts, requestMeta)
+						: await http.requestSafe(method, path, opts, requestMeta)
 
 				if (staleUntil) {
-					const isSuccess = config.throwOnError === true
-						? true
-						: ((result as { status: number }).status >= 200 && (result as { status: number }).status < 300)
+					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) {

package/src/client/types.ts

@@ -57,11 +57,7 @@ export type OutputFor<TRoutes, P extends string, M extends string> =
 
 /** Check if a route returns SSE (text/event-stream in output) */
 export type IsSSE<TRoutes, P extends string, M extends string> =
-	OutputDefFor<TRoutes, P, M> extends infer O
-		? O extends { "text/event-stream": unknown }
-			? true
-			: false
-		: false
+	OutputDefFor<TRoutes, P, M> extends infer O ? (O extends { "text/event-stream": unknown } ? true : false) : false
 
 /** Extract errorsByStatus from route record if available */
 type ErrorsByStatusFor<TRoutes, P extends string, M extends string> = P extends keyof TRoutes
@@ -109,8 +105,8 @@ type ErrorVariants<TErrorsByStatus> = {
 export type ClientResult<TData, TErrorsByStatus = never> =
 	| { data: TData; error: null; response: Response; status: number }
 	| (HasStatusErrors<TErrorsByStatus> extends false
-		? { data: null; error: unknown; response: Response; status: number }
-		: ErrorVariants<TErrorsByStatus>)
+			? { data: null; error: unknown; response: Response; status: number }
+			: ErrorVariants<TErrorsByStatus>)
 
 /** Resolve return type based on transport + throw mode */
 export type ReturnFor<TRoutes, P extends string, M extends string, TThrow extends boolean = true> =
@@ -121,8 +117,7 @@ export type ReturnFor<TRoutes, P extends string, M extends string, TThrow extend
 			: Promise<ClientResult<OutputFor<TRoutes, P, M>, ErrorsByStatusFor<TRoutes, P, M>>>
 
 /** Build the client input type — merge route input with params from path */
-export type ClientInput<TRoutes, P extends string, M extends string> = InputFor<TRoutes, P, M> &
-	ParamsInput<P>
+export type ClientInput<TRoutes, P extends string, M extends string> = InputFor<TRoutes, P, M> & ParamsInput<P>
 
 /** Extract params input if path has params */
 type ParamsInput<P extends string> =

package/src/client/ws.ts

@@ -55,10 +55,7 @@ export function createTypedWebSocket(
 				break
 			case "close":
 				wrapped = (e: Event) =>
-					(handler as (code: number, reason: string) => void)(
-						(e as CloseEvent).code,
-						(e as CloseEvent).reason,
-					)
+					(handler as (code: number, reason: string) => void)((e as CloseEvent).code, (e as CloseEvent).reason)
 				break
 			case "error":
 				wrapped = (e: Event) => (handler as (error: unknown) => void)(e)
@@ -80,7 +77,8 @@ export function createTypedWebSocket(
 
 	function toWsData(data: ArrayBuffer | ArrayBufferView | string): string | Uint8Array<ArrayBuffer> {
 		if (typeof data === "string") return data
-		const view = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+		const view =
+			data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
 		const copy = new Uint8Array(view.byteLength)
 		copy.set(view)
 		return copy

package/src/client-mcp/server.ts

@@ -11,10 +11,7 @@
 /* eslint-disable @typescript-eslint/no-deprecated */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import {
-	CallToolRequestSchema,
-	ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js"
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
 import type { Tool, ToolResult } from "./types.ts"
 
 type ServerError = Error & { status?: number; body?: unknown; data?: unknown }

package/src/cloudflare/realtime.ts

@@ -42,9 +42,7 @@ type Attachment = {
 const DEFAULT_BUFFER_SIZE = 100
 const BUFFER_TTL_MS = 30_000
 
-export function createRealtimeHandlers<TEnv = unknown>(
-	config: RealtimeHandlerConfig<TEnv>,
-): RealtimeHandlers {
+export function createRealtimeHandlers<TEnv = unknown>(config: RealtimeHandlerConfig<TEnv>): RealtimeHandlers {
 	const bufferSize = config.reconnectBuffer ?? DEFAULT_BUFFER_SIZE
 	const buffer = new ReconnectBuffer({ size: bufferSize })
 	const bus = createBus()
@@ -70,7 +68,7 @@ export function createRealtimeHandlers<TEnv = unknown>(
 	}
 
 	function sendFrame(ws: WebSocket, frame: ServerFrame): void {
-		(ws as unknown as { send(data: string): void }).send(encodeServerFrame(frame))
+		;(ws as unknown as { send(data: string): void }).send(encodeServerFrame(frame))
 	}
 
 	function getRouteHandler(): ((c: unknown, conn: ConnContext) => void | Promise<void>) | null {
@@ -85,7 +83,7 @@ export function createRealtimeHandlers<TEnv = unknown>(
 		return createConnContext({
 			bus,
 			closeFn: (reason) => {
-				(ws as unknown as { close(code?: number, reason?: string): void }).close(1000, reason ?? "")
+				;(ws as unknown as { close(code?: number, reason?: string): void }).close(1000, reason ?? "")
 			},
 			id: attachment.connId,
 			sendFn: (payload) => {
@@ -109,7 +107,9 @@ export function createRealtimeHandlers<TEnv = unknown>(
 			userId = await config.onAuth(req)
 		}
 
-		const pair = new (globalThis as unknown as { WebSocketPair: new () => { 0: WebSocket; 1: WebSocket } }).WebSocketPair()
+		const pair = new (
+			globalThis as unknown as { WebSocketPair: new () => { 0: WebSocket; 1: WebSocket } }
+		).WebSocketPair()
 		const client = pair[0]
 		const server = pair[1]
 
@@ -120,9 +120,7 @@ export function createRealtimeHandlers<TEnv = unknown>(
 		knownTokens.add(reconnectToken)
 
 		const attachment: Attachment = { connId, reconnectToken, userId }
-		;(server as unknown as { serializeAttachment(data: string): void }).serializeAttachment(
-			JSON.stringify(attachment),
-		)
+		;(server as unknown as { serializeAttachment(data: string): void }).serializeAttachment(JSON.stringify(attachment))
 
 		sendFrame(server, { reconnectToken, t: "ready" })
 
@@ -215,7 +213,7 @@ export function createRealtimeHandlers<TEnv = unknown>(
 
 	function handleError(ws: WebSocket, _err: unknown): Promise<void> {
 		try {
-			(ws as unknown as { close(code?: number, reason?: string): void }).close(1011, "internal error")
+			;(ws as unknown as { close(code?: number, reason?: string): void }).close(1011, "internal error")
 		} catch {
 			/* swallow — ws may already be closed */
 		}

package/src/codegen-go-cli.ts

@@ -82,11 +82,11 @@ type BodyShape =
 	| { kind: "json-flat"; scalars: BodyScalarInfo[]; required: boolean }
 	| { kind: "json-complex"; required: boolean }
 	| {
-		kind: "multipart"
-		binaryFields: { name: string; required: boolean }[]
-		scalarFields: BodyScalarInfo[]
-		useGenericFileFlag: boolean
-	}
+			kind: "multipart"
+			binaryFields: { name: string; required: boolean }[]
+			scalarFields: BodyScalarInfo[]
+			useGenericFileFlag: boolean
+	  }
 
 type CommandInfo = {
 	opId: string
@@ -163,16 +163,7 @@ let runtimeCache: Map<string, string> | null = null
 /** Reads static .go runtime files from ./cli-go/ and caches them. */
 export function loadGoCliRuntimeTemplates(): Map<string, string> {
 	if (runtimeCache) return runtimeCache
-	const names = [
-		"config.go",
-		"auth.go",
-		"output.go",
-		"errors.go",
-		"stream.go",
-		"multipart.go",
-		"version.go",
-		"root.go",
-	]
+	const names = ["config.go", "auth.go", "output.go", "errors.go", "stream.go", "multipart.go", "version.go", "root.go"]
 	const cache = new Map<string, string>()
 	for (const name of names) {
 		const filePath = fileURLToPath(new URL(`./cli-go/${name}`, import.meta.url))
@@ -190,10 +181,7 @@ export function loadGoCliRuntimeTemplates(): Map<string, string> {
 
 /* ── param + body helpers ── */
 
-function getPathParams(
-	op: Record<string, unknown>,
-	rawPath: string,
-): ParamInfo[] {
+function getPathParams(op: Record<string, unknown>, rawPath: string): ParamInfo[] {
 	const declared = extractOpenApiPathParams(rawPath)
 	const byName = new Map<string, Record<string, unknown>>()
 	const parameters = (op.parameters as Array<Record<string, unknown>> | undefined) ?? []
@@ -333,9 +321,11 @@ function hasJsonResponse(op: Record<string, unknown>): boolean {
 
 /* ── command collection ── */
 
-function collectCLIMethods(
-	spec: Record<string, unknown>,
-): { groups: Map<string, ResourceGroup>; skipped: string[]; serviceMap: Record<string, Record<string, unknown>> } {
+function collectCLIMethods(spec: Record<string, unknown>): {
+	groups: Map<string, ResourceGroup>
+	skipped: string[]
+	serviceMap: Record<string, Record<string, unknown>>
+} {
 	toIR(spec as Parameters<typeof toIR>[0])
 	const { serviceMap } = collectSDKMethods(spec as Parameters<typeof collectSDKMethods>[0])
 	const resolved = resolveRefs(spec as Parameters<typeof resolveRefs>[0]) as unknown as OpenApiSpec
@@ -609,12 +599,7 @@ function emitResourceFile(group: ResourceGroup, options: GoCLIOptions): string {
 }
 
 /** Emits var declarations for every flag-backing Go variable + the cobra.Command literal. */
-function emitCommand(
-	l: string[],
-	group: ResourceGroup,
-	cmd: CommandInfo,
-	options: GoCLIOptions,
-): void {
+function emitCommand(l: string[], group: ResourceGroup, cmd: CommandInfo, options: GoCLIOptions): void {
 	/* flag-backing vars */
 	for (const p of cmd.pathParams) {
 		l.push(`var ${cmd.cmdVarName}${goPascal(p.name)}Var string`)
@@ -689,7 +674,9 @@ function emitFlagRegistrations(l: string[], cmd: CommandInfo): void {
 		const v = `${cmd.cmdVarName}${goPascal(p.name)}Var`
 		/* flag docstring references original param name for discoverability */
 		l.push(`\t/* Path flag — Use: ${JSON.stringify(p.name)} */`)
-		l.push(`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(p.flagName)}, "", ${JSON.stringify(`Path parameter ${p.name}`)})`)
+		l.push(
+			`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(p.flagName)}, "", ${JSON.stringify(`Path parameter ${p.name}`)})`,
+		)
 		l.push(`\t${cmd.cmdVarName}.MarkFlagRequired(${JSON.stringify(p.flagName)})`)
 	}
 	for (const q of cmd.queryParams) {
@@ -697,7 +684,9 @@ function emitFlagRegistrations(l: string[], cmd: CommandInfo): void {
 		emitQueryFlag(l, cmd, q)
 	}
 	if (cmd.body.kind === "json-flat" || cmd.body.kind === "json-complex") {
-		l.push(`\t${cmd.cmdVarName}.Flags().StringVar(&${cmd.cmdVarName}DataVar, "data", "", "Request body: JSON literal, @file, or - for stdin")`)
+		l.push(
+			`\t${cmd.cmdVarName}.Flags().StringVar(&${cmd.cmdVarName}DataVar, "data", "", "Request body: JSON literal, @file, or - for stdin")`,
+		)
 	}
 	if (cmd.body.kind === "json-flat") {
 		for (const s of cmd.body.scalars) {
@@ -717,7 +706,9 @@ function emitFlagRegistrations(l: string[], cmd: CommandInfo): void {
 		} else {
 			for (const f of cmd.body.binaryFields) {
 				const v = `${cmd.cmdVarName}${goPascal(f.name)}Var`
-				l.push(`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(toFlagName(f.name))}, "", ${JSON.stringify(`Path to ${f.name} file`)})`)
+				l.push(
+					`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(toFlagName(f.name))}, "", ${JSON.stringify(`Path to ${f.name} file`)})`,
+				)
 				if (f.required) {
 					l.push(`\t${cmd.cmdVarName}.MarkFlagRequired(${JSON.stringify(toFlagName(f.name))})`)
 				}
@@ -725,16 +716,17 @@ function emitFlagRegistrations(l: string[], cmd: CommandInfo): void {
 		}
 	}
 	if (cmd.hasLastEventId) {
-		l.push(`\t${cmd.cmdVarName}.Flags().StringVar(&${cmd.cmdVarName}LastEventIDVar, "last-event-id", "", "SSE Last-Event-ID resume token")`)
+		l.push(
+			`\t${cmd.cmdVarName}.Flags().StringVar(&${cmd.cmdVarName}LastEventIDVar, "last-event-id", "", "SSE Last-Event-ID resume token")`,
+		)
 	}
 }
 
 function emitQueryFlag(l: string[], cmd: CommandInfo, q: ParamInfo): void {
 	const v = `${cmd.cmdVarName}${goPascal(q.name)}Var`
 	const t = q.schema.type
-	const help = q.enumValues.length > 0
-		? `Query param ${q.name} (one of: ${q.enumValues.join(", ")})`
-		: `Query param ${q.name}`
+	const help =
+		q.enumValues.length > 0 ? `Query param ${q.name} (one of: ${q.enumValues.join(", ")})` : `Query param ${q.name}`
 	const helpStr = JSON.stringify(help)
 
 	if (t === "integer") {
@@ -745,14 +737,18 @@ function emitQueryFlag(l: string[], cmd: CommandInfo, q: ParamInfo): void {
 		l.push(`\t${cmd.cmdVarName}.Flags().Float64Var(&${v}, ${JSON.stringify(q.flagName)}, ${def}, ${helpStr})`)
 	} else if (t === "boolean") {
 		const def = q.defaultValue === true
-		l.push(`\t${cmd.cmdVarName}.Flags().BoolVar(&${v}, ${JSON.stringify(q.flagName)}, ${def ? "true" : "false"}, ${helpStr})`)
+		l.push(
+			`\t${cmd.cmdVarName}.Flags().BoolVar(&${v}, ${JSON.stringify(q.flagName)}, ${def ? "true" : "false"}, ${helpStr})`,
+		)
 	} else if (t === "array") {
 		const defArr = Array.isArray(q.defaultValue) ? q.defaultValue : []
 		const defStr = `[]string{${defArr.map((x) => JSON.stringify(String(x))).join(", ")}}`
 		l.push(`\t${cmd.cmdVarName}.Flags().StringSliceVar(&${v}, ${JSON.stringify(q.flagName)}, ${defStr}, ${helpStr})`)
 	} else {
 		const def = typeof q.defaultValue === "string" ? q.defaultValue : ""
-		l.push(`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(q.flagName)}, ${JSON.stringify(def)}, ${helpStr})`)
+		l.push(
+			`\t${cmd.cmdVarName}.Flags().StringVar(&${v}, ${JSON.stringify(q.flagName)}, ${JSON.stringify(def)}, ${helpStr})`,
+		)
 	}
 	if (q.required) {
 		l.push(`\t${cmd.cmdVarName}.MarkFlagRequired(${JSON.stringify(q.flagName)})`)
@@ -761,9 +757,10 @@ function emitQueryFlag(l: string[], cmd: CommandInfo, q: ParamInfo): void {
 
 function emitBodyScalarFlag(l: string[], cmd: CommandInfo, s: BodyScalarInfo): void {
 	const v = `${cmd.cmdVarName}${goPascal(s.propName)}Var`
-	const help = s.enumValues.length > 0
-		? `Body field ${s.propName} (one of: ${s.enumValues.join(", ")})`
-		: `Body field ${s.propName}`
+	const help =
+		s.enumValues.length > 0
+			? `Body field ${s.propName} (one of: ${s.enumValues.join(", ")})`
+			: `Body field ${s.propName}`
 	const helpStr = JSON.stringify(help)
 	if (s.schemaType === "integer") {
 		l.push(`\t${cmd.cmdVarName}.Flags().Int64Var(&${v}, ${JSON.stringify(s.flagName)}, 0, ${helpStr})`)
@@ -809,7 +806,9 @@ function emitPreRunE(cmd: CommandInfo): string[] {
 			if (s.schemaType !== "string") continue
 			const v = `${cmd.cmdVarName}${goPascal(s.propName)}Var`
 			const values = s.enumValues.map((x) => JSON.stringify(x)).join(", ")
-			lines.push(`if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) && !slices.Contains([]string{${values}}, ${v}) {`)
+			lines.push(
+				`if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) && !slices.Contains([]string{${values}}, ${v}) {`,
+			)
 			lines.push(`\treturn fmt.Errorf("--${s.flagName} must be one of: ${s.enumValues.join(", ")}")`)
 			lines.push(`}`)
 		}
@@ -858,12 +857,16 @@ function emitRunE(l: string[], cmd: CommandInfo, _options: GoCLIOptions): void {
 		l.push(`${ind}\tdataBytes, derr := cli.ReadDataFlag(${cmd.cmdVarName}DataVar)`)
 		l.push(`${ind}\tif derr != nil { return derr }`)
 		l.push(`${ind}\tif len(dataBytes) > 0 {`)
-		l.push(`${ind}\t\tif jerr := json.Unmarshal(dataBytes, &merged); jerr != nil { return fmt.Errorf("parse --data: %w", jerr) }`)
+		l.push(
+			`${ind}\t\tif jerr := json.Unmarshal(dataBytes, &merged); jerr != nil { return fmt.Errorf("parse --data: %w", jerr) }`,
+		)
 		l.push(`${ind}\t}`)
 		l.push(`${ind}}`)
 		for (const s of cmd.body.scalars) {
 			const v = `${cmd.cmdVarName}${goPascal(s.propName)}Var`
-			l.push(`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { merged[${JSON.stringify(s.propName)}] = ${v} }`)
+			l.push(
+				`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { merged[${JSON.stringify(s.propName)}] = ${v} }`,
+			)
 		}
 		l.push(`${ind}bodyBytes, merr := json.Marshal(merged)`)
 		l.push(`${ind}if merr != nil { return merr }`)
@@ -879,15 +882,21 @@ function emitRunE(l: string[], cmd: CommandInfo, _options: GoCLIOptions): void {
 		for (const s of cmd.body.scalarFields) {
 			const v = `${cmd.cmdVarName}${goPascal(s.propName)}Var`
 			if (s.schemaType === "string") {
-				l.push(`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { fields[${JSON.stringify(s.propName)}] = ${v} }`)
+				l.push(
+					`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { fields[${JSON.stringify(s.propName)}] = ${v} }`,
+				)
 			} else {
-				l.push(`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { fields[${JSON.stringify(s.propName)}] = fmt.Sprint(${v}) }`)
+				l.push(
+					`${ind}if cmd.Flags().Changed(${JSON.stringify(s.flagName)}) { fields[${JSON.stringify(s.propName)}] = fmt.Sprint(${v}) }`,
+				)
 			}
 		}
 		l.push(`${ind}files := map[string]string{}`)
 		if (cmd.body.useGenericFileFlag) {
 			const bin = cmd.body.binaryFields[0]
-			l.push(`${ind}if ${cmd.cmdVarName}FileVar != "" { files[${JSON.stringify(bin.name)}] = ${cmd.cmdVarName}FileVar }`)
+			l.push(
+				`${ind}if ${cmd.cmdVarName}FileVar != "" { files[${JSON.stringify(bin.name)}] = ${cmd.cmdVarName}FileVar }`,
+			)
 		} else {
 			for (const f of cmd.body.binaryFields) {
 				const v = `${cmd.cmdVarName}${goPascal(f.name)}Var`
@@ -908,7 +917,9 @@ function emitRunE(l: string[], cmd: CommandInfo, _options: GoCLIOptions): void {
 		l.push(`${ind}req.Header.Set("Accept", "text/event-stream")`)
 		l.push(`${ind}if apiKey != "" { req.Header.Set("Authorization", "Bearer "+apiKey) }`)
 		if (cmd.hasLastEventId) {
-			l.push(`${ind}if ${cmd.cmdVarName}LastEventIDVar != "" { req.Header.Set("Last-Event-ID", ${cmd.cmdVarName}LastEventIDVar) }`)
+			l.push(
+				`${ind}if ${cmd.cmdVarName}LastEventIDVar != "" { req.Header.Set("Last-Event-ID", ${cmd.cmdVarName}LastEventIDVar) }`,
+			)
 		}
 		l.push(`${ind}resp, herr := httpClient.Do(req)`)
 		l.push(`${ind}if herr != nil { return herr }`)
@@ -941,7 +952,9 @@ function emitRunE(l: string[], cmd: CommandInfo, _options: GoCLIOptions): void {
 	l.push(`${ind}body, berr := io.ReadAll(resp.Body)`)
 	l.push(`${ind}if berr != nil { return berr }`)
 	l.push(`${ind}if resp.StatusCode >= 400 {`)
-	l.push(`${ind}\treturn &sdk.StatusError{StatusCode: resp.StatusCode, Body: body, Response: resp, Message: string(body)}`)
+	l.push(
+		`${ind}\treturn &sdk.StatusError{StatusCode: resp.StatusCode, Body: body, Response: resp, Message: string(body)}`,
+	)
 	l.push(`${ind}}`)
 	if (cmd.has204) {
 		l.push(`${ind}if resp.StatusCode == http.StatusNoContent { return nil }`)
@@ -970,11 +983,16 @@ function buildPathExpr(cmd: CommandInfo): string {
 function querySetStmt(q: ParamInfo, v: string): string {
 	const name = JSON.stringify(q.name)
 	switch (q.schema.type) {
-		case "integer": return `q.Set(${name}, fmt.Sprintf("%d", ${v}))`
-		case "number": return `q.Set(${name}, fmt.Sprintf("%g", ${v}))`
-		case "boolean": return `q.Set(${name}, fmt.Sprintf("%t", ${v}))`
-		case "array": return `for _, v := range ${v} { q.Add(${name}, v) }`
-		default: return `q.Set(${name}, ${v})`
+		case "integer":
+			return `q.Set(${name}, fmt.Sprintf("%d", ${v}))`
+		case "number":
+			return `q.Set(${name}, fmt.Sprintf("%g", ${v}))`
+		case "boolean":
+			return `q.Set(${name}, fmt.Sprintf("%t", ${v}))`
+		case "array":
+			return `for _, v := range ${v} { q.Add(${name}, v) }`
+		default:
+			return `q.Set(${name}, ${v})`
 	}
 }
 
@@ -1087,11 +1105,7 @@ function emitReadme(spec: OpenApiSpec, options: GoCLIOptions): string {
 
 /* ── embedded SDK copy ── */
 
-function copyEmbeddedSDK(
-	spec: Record<string, unknown>,
-	options: GoCLIOptions,
-	outFiles: Record<string, string>,
-): void {
+function copyEmbeddedSDK(spec: Record<string, unknown>, options: GoCLIOptions, outFiles: Record<string, string>): void {
 	const sdkModule = `${resolveModulePath(options)}/internal/sdk`
 	const sdkGen = generateGoSDK(spec, { modulePath: sdkModule })
 	for (const [name, content] of Object.entries(sdkGen.files)) {
@@ -1107,11 +1121,7 @@ function copyEmbeddedSDK(
  *   When embedding, add a small sse_export.go into internal/sdk/.
  *   When using external SDK, we still need the same symbol — emit an adapter file. */
 
-function emitSSEExportShim(
-	options: GoCLIOptions,
-	files: Record<string, string>,
-	hasEmbedded: boolean,
-): void {
+function emitSSEExportShim(options: GoCLIOptions, files: Record<string, string>, hasEmbedded: boolean): void {
 	const shim = [
 		`// Code generated by honey. DO NOT EDIT.`,
 		`package sdk`,
@@ -1137,10 +1147,7 @@ function emitSSEExportShim(
 
 /* ── public entrypoint ── */
 
-export function generateGoCLI(
-	spec: Record<string, unknown>,
-	options: GoCLIOptions,
-): GeneratedGoCLI {
+export function generateGoCLI(spec: Record<string, unknown>, options: GoCLIOptions): GeneratedGoCLI {
 	const resolved = resolveRefs(spec as Parameters<typeof resolveRefs>[0]) as unknown as OpenApiSpec
 	const { groups, skipped, serviceMap } = collectCLIMethods(spec)