@kubb/plugin-fetch 5.13.0-canary.20261105T105941 → 5.13.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, injectFile, macroSimplifyUnion, pascalCase, setMacros, setResolver, useConfig } from "@kubb/kit";
+import { createRequire } from "node:module";
+import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, injectFile, macroDedupeUnion, pascalCase, setMacros, setResolver, useConfig } from "@kubb/kit";
 import path from "node:path";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
@@ -85,20 +86,33 @@ function getPrimarySuccessContentType(node) {
 	return contentTypes[0].split(";")[0].trim().toLowerCase();
 }
 /**
-* Whether an operation streams its primary success response as Server-Sent Events
-* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
-* one-shot `RequestResult`.
+* The `text/event-stream` content of the primary success response, when it is the only content type. A response that also
+* declares another type stays a normal call with its query hooks.
+*/
+function getEventStreamContent(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream" ? getPrimarySuccessResponse(node)?.content?.[0] : void 0;
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events (`text/event-stream`). The client
+* generator uses this to return a typed event stream instead of a one-shot `RequestResult`.
 */
 function isEventStream(node) {
-	return getPrimarySuccessContentType(node) === "text/event-stream";
+	return getEventStreamContent(node) !== void 0;
+}
+/**
+* How the document types a `text/event-stream` response, as the adapter read it from `itemSchema`: `event` when each item is
+* the parsed event with its own `event` and `data`, `data` when it is only the payload. Returns `null` without an event stream.
+*/
+function getEventStream(node) {
+	const content = getEventStreamContent(node);
+	return content ? content.stream?.shape ?? "data" : null;
 }
 /**
 * Derives the default `responseType` for an operation from its primary success response.
 *
-* Returns a value only when that response declares a single non-JSON content type. `text/event-stream`
-* and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,
-* `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,
-* leaving the runtime client's `Content-Type` auto-detection in charge.
+* Returns a value only when that response declares a single non-JSON content type. `text/event-stream` maps to
+* `'stream'`, `application/octet-stream`, `application/pdf`, `image/*`, `audio/*` and `video/*` map to `'blob'`, and
+* other `text/*` to `'text'`. Otherwise `undefined`, leaving the runtime client's `Content-Type` auto-detection in charge.
 */
 function getResponseType(node) {
 	const baseType = getPrimarySuccessContentType(node);
@@ -158,6 +172,22 @@ function buildOperationComments(node, options = {}) {
 }
 const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 /**
+* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
+* per property, typed and serialized like any other.
+* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
+*/
+function spreadQuerystring(param) {
+	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
+	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
+	if (schema?.type !== "object" || !formEncoded) return [param];
+	return schema.properties.map((property) => ast.factory.createParameter({
+		name: property.name,
+		in: "query",
+		schema: property.schema,
+		required: param.required && property.required
+	}));
+}
+/**
 * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
 * group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
 * (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
@@ -166,17 +196,18 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
-	const group = (location) => {
+	const dedupe = (params) => {
 		const seen = /* @__PURE__ */ new Set();
-		return node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
+		return params.filter((param) => {
+			if (seen.has(param.name)) return false;
 			seen.add(param.name);
 			return true;
 		});
 	};
+	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
 	const groups = {
 		path: group("path"),
-		query: group("query"),
+		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
 		header: group("header"),
 		cookie: group("cookie")
 	};
@@ -463,6 +494,114 @@ function buildZodErrorParse(node, zodResolver) {
 	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
 	return zodResolver.response.error?.(node) || null;
 }
+// ../../internals/client/src/builders/generics.ts
+/**
+* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
+* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
+* runtime, so this only names the record and threads `ThrowOnError`.
+*
+* @example
+* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
+*/
+function buildRequestResultGenerics({ node, types }) {
+	return `${types.response.responses(node)}, ThrowOnError`;
+}
+/**
+* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
+* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
+* `Promise<RequestResult>` for the internal `'plain'` shape, or a
+* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
+* down to the bare success body.
+*
+* @example
+* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
+*/
+function buildResultType({ node, types, returnType }) {
+	const generics = buildRequestResultGenerics({
+		node,
+		types
+	});
+	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
+	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
+	return `Unwrappable<RequestResult<${generics}>>`;
+}
+// ../../internals/client/src/builders/returnStatement.ts
+/**
+* Builds the return statement of a generated operation function. With the default
+* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
+* The generated code casts that result to the operation's `RequestResult`, then wraps it with
+* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
+* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
+* which narrows the resolved value down to the bare success body the same way `RequestResult`
+* already does, using the plugin default when the call leaves `throwOnError` unset.
+* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
+*
+* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
+* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
+* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
+* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
+*
+* @example
+* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
+* @example
+* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
+*/
+function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
+	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
+	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
+		node,
+		types,
+		returnType
+	})}`;
+	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>`;
+	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>)`;
+}
+/**
+* Builds the return type and statement of a `text/event-stream` operation. The item type is `TypedEvent<...>` when each item
+* declares its own `event` and `data`, and otherwise the payload type, which `EventStreamResult` wraps in `ServerSentEvent`. The call's
+* promise goes through `toEventStream` with the `client` for its defaults, the call's `config`, the shape and the per-event
+* validator. A `returnType: 'plain'` client receives only the promise,
+* `toEventStream(request(config))`, and keeps its response validator in the call config.
+*/
+function buildEventStreamReturn({ node, types, callConfig, returnType, validatorHooks, throwOnErrorDefault }) {
+	const shape = getEventStream(node) ?? "data";
+	const responses = types.response.responses(node);
+	const success = `SuccessOf<${responses}>`;
+	const eventType = shape === "event" ? `TypedEvent<${success}>` : success;
+	if (returnType === "plain") return {
+		returnType: `Promise<EventStreamResult<${eventType}>>`,
+		statement: `return toEventStream<${eventType}>(request(${callConfig}))`
+	};
+	const generics = `${responses}, ThrowOnError${shape === "event" ? `, ${eventType}` : ""}`;
+	const call = `toEventStream<${eventType}>(request(${callConfig}), { client: request, config, ${[`shape: '${shape}'`, validatorHooks?.response ? `validator: ${validatorHooks.response}` : null].filter(Boolean).join(", ")} })`;
+	if (returnType === "data") {
+		const result = `Promise<UnwrappedStreamResult<${generics}>>`;
+		return {
+			returnType: result,
+			statement: `return unwrapResult(${call}, config.throwOnError ?? ${throwOnErrorDefault}) as ${result}`
+		};
+	}
+	return {
+		returnType: `Unwrappable<StreamResult<${generics}>>`,
+		statement: `return withUnwrap(${call} as Promise<StreamResult<${generics}>>)`
+	};
+}
+/** The stream types an operation file imports: `StreamResult` and `StreamOptions`, `EventStreamResult` for a plain client, and `TypedEvent` for named events. */
+function buildEventStreamImports({ returnType, typed }) {
+	return [...{
+		plain: ["EventStreamResult"],
+		full: ["StreamResult", "StreamOptions"],
+		data: ["UnwrappedStreamResult", "StreamOptions"]
+	}[returnType], ...typed ? ["TypedEvent"] : []];
+}
 // ../../internals/client/src/builders/security.ts
 function serializeAuth(auth) {
 	const parts = [`type: '${auth.type}'`];
@@ -618,6 +757,7 @@ function serializeParameter(parameter) {
 	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
 	if (parameter.in === "query" && parameter.allowReserved !== void 0) parts.push(`allowReserved: ${parameter.allowReserved}`);
 	if (parameter.in !== "path" && parameter.contentType) parts.push(`contentType: '${parameter.contentType}'`);
+	if (parameter.in === "querystring") parts.push("querystring: true");
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
@@ -660,10 +800,9 @@ function buildStyles({ node }) {
 		header: [],
 		cookie: []
 	};
-	for (const parameter of node.parameters) {
+	for (const [location, parameters] of Object.entries(getOperationParameters(node))) for (const parameter of parameters) {
 		const literal = serializeParameter(parameter);
-		if (!literal) continue;
-		groups[parameter.in].push(`${toKey(parameter.name)}: ${literal}`);
+		if (literal) groups[location].push(`${toKey(parameter.name)}: ${literal}`);
 	}
 	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
 	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
@@ -674,12 +813,20 @@ function buildStyles({ node }) {
 * functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
 *
 * `mergeContentType` is `true` when the caller must destructure `contentType` from `options`, and
-* `eventStream` is `true` when the operation returns `text/event-stream`.
+* `eventStream` is `true` when the operation returns `text/event-stream`. Unless `returnType` is `'plain'`, a
+* stream's literal leaves the `response` validator to `toEventStream`, which runs it per event.
 */
-function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault }) {
+function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
+	const eventStream = isEventStream(node);
 	const securityLiteral = buildSecurityMetadata({ security });
 	const stylesLiteral = buildStyles({ node });
-	const validatorLiteral = buildValidatorLiteral(validatorHooks, [
+	const validatorLiteral = buildValidatorLiteral(validatorHooks, eventStream && returnType !== "plain" ? [
+		"request",
+		"path",
+		"query",
+		"headers",
+		"error"
+	] : [
 		"request",
 		"path",
 		"query",
@@ -702,88 +849,7 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault }
 			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 		].filter(Boolean).join(", ")} }`,
 		mergeContentType,
-		eventStream: isEventStream(node)
-	};
-}
-// ../../internals/client/src/builders/generics.ts
-/**
-* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
-* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
-* runtime, so this only names the record and threads `ThrowOnError`.
-*
-* @example
-* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
-*/
-function buildRequestResultGenerics({ node, types }) {
-	return `${types.response.responses(node)}, ThrowOnError`;
-}
-/**
-* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
-* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
-* `Promise<RequestResult>` for the internal `'plain'` shape, or a
-* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
-* down to the bare success body.
-*
-* @example
-* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
-*/
-function buildResultType({ node, types, returnType }) {
-	const generics = buildRequestResultGenerics({
-		node,
-		types
-	});
-	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
-	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
-	return `Unwrappable<RequestResult<${generics}>>`;
-}
-// ../../internals/client/src/builders/returnStatement.ts
-/**
-* Builds the return statement of a generated operation function. With the default
-* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
-* The generated code casts that result to the operation's `RequestResult`, then wraps it with
-* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
-* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
-* which narrows the resolved value down to the bare success body the same way `RequestResult`
-* already does, using the plugin default when the call leaves `throwOnError` unset.
-* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
-*
-* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
-* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
-* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
-* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
-*
-* @example
-* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
-* @example
-* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
-* @example
-* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
-*/
-function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
-	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
-	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
-		node,
-		types,
-		returnType
-	})}`;
-	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>`;
-	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>)`;
-}
-/**
-* Builds the return type and statement of an operation that returns `text/event-stream`: the call
-* is wrapped in `toEventStream`, so the caller iterates the typed success events.
-*/
-function buildEventStreamReturn({ node, types, callConfig }) {
-	const eventType = `SuccessOf<${types.response.responses(node)}>`;
-	return {
-		returnType: `Promise<EventStreamResult<${eventType}>>`,
-		statement: `return toEventStream<${eventType}>(request(${callConfig}))`
+		eventStream
 	};
 }
 // ../../internals/client/src/builders/signature.ts
@@ -797,13 +863,14 @@ const declarationPrinter = functionPrinter({ mode: "declaration" });
 * per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
 * `plugin-zod`'s inferred types (see `resolveOperationTypes`).
 */
-function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault }) {
+function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault, eventStream = false }) {
 	const optionsName = types.response.options(node);
+	const optionsType = `${eventStream && returnType !== "plain" ? "StreamOptions" : "Options"}<${optionsName}, ThrowOnError>`;
 	const { isOptional } = getRequestGroupOptionality(node);
 	return {
 		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
 			name: "options",
-			type: `Options<${optionsName}, ThrowOnError>`,
+			type: optionsType,
 			...isOptional ? { default: "{}" } : {}
 		})] })) ?? "",
 		returnType: buildResultType({
@@ -814,37 +881,63 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
 	};
 }
-// ../../internals/client/src/components/Operation.tsx
+// ../../internals/client/src/builders/operationBody.ts
 /**
-* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
-* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
-* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
-* the source.
+* The pieces of a generated operation: its generics, `options` parameter, return type, return statement, and whether the
+* body destructures `contentType` from `options`. Shared by the standalone functions and the SDK methods, so a
+* `text/event-stream` operation is wired to `toEventStream` in one place.
 */
-function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
-	if (!ast.isHttpOperationNode(node)) return null;
+function buildOperationBody({ node, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
+	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
+		node,
+		validatorHooks,
+		security,
+		throwOnErrorDefault,
+		returnType
+	});
 	const signature = buildGroupedOptionsSignature({
 		node,
 		types,
 		returnType,
-		throwOnErrorDefault
+		throwOnErrorDefault,
+		eventStream
 	});
-	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
+	const stream = eventStream ? buildEventStreamReturn({
 		node,
+		types,
+		callConfig,
+		returnType,
 		validatorHooks,
-		security,
 		throwOnErrorDefault
-	});
-	const eventStreamReturn = eventStream ? buildEventStreamReturn({
-		node,
-		types,
-		callConfig
 	}) : null;
-	const functionReturnType = eventStreamReturn?.returnType ?? signature.returnType;
-	const returnStatement = eventStreamReturn?.statement ?? buildReturnStatement({
+	return {
+		generics: signature.generics,
+		paramsSignature: signature.paramsSignature,
+		returnType: stream?.returnType ?? signature.returnType,
+		statement: stream?.statement ?? buildReturnStatement({
+			node,
+			types,
+			callConfig,
+			returnType,
+			throwOnErrorDefault
+		}),
+		mergeContentType
+	};
+}
+// ../../internals/client/src/components/Operation.tsx
+/**
+* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
+* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
+* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
+* the source.
+*/
+function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const body = buildOperationBody({
 		node,
 		types,
-		callConfig,
+		validatorHooks,
+		security,
 		returnType,
 		throwOnErrorDefault
 	});
@@ -855,22 +948,53 @@ function Operation({ name, node, types, validatorHooks, returnType, throwOnError
 		children: /* @__PURE__ */ jsxs(Function, {
 			name,
 			export: true,
-			generics: signature.generics,
-			params: signature.paramsSignature,
-			returnType: functionReturnType,
+			generics: body.generics,
+			params: body.paramsSignature,
+			returnType: body.returnType,
 			JSDoc: { comments: buildOperationComments(node, {
 				link: "urlPath",
 				linkPosition: "beforeDeprecated",
 				splitLines: true
 			}) },
 			children: [
-				mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
+				body.mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
 				/* @__PURE__ */ jsx("br", {}),
-				returnStatement
+				body.statement
 			]
 		})
 	});
 }
+// ../../internals/client/src/components/StreamRuntime.tsx
+/**
+* The `footer` of `.kubb/client.ts`: the `baseURL` set at generation time, and the `sse.ts` re-export when the document
+* streams events, so `ServerSentEvent` and `toEventStream` stay importable from the client as in earlier releases.
+*/
+function buildClientFooter({ baseURL, sse }) {
+	const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
+	return [baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : null, sse ? `export * from './sse.ts'` : null].filter(Boolean).join("\n") || void 0;
+}
+/**
+* Writes the footer of the `.kubb/client.ts` the plugin injected, the one place it is built, and copies `sse.ts` into
+* `.kubb/` only for a document with a `text/event-stream` operation, so a document without streams ships no stream runtime.
+* `sse` is set by the plugins that ship the runtime, so a custom client from `@kubb/plugin-client` gets neither file.
+*/
+function StreamRuntime({ nodes, root, sse, baseURL }) {
+	if (!sse) return null;
+	const streams = nodes.some(isEventStream);
+	const footer = buildClientFooter({
+		baseURL,
+		sse: streams
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [streams && /* @__PURE__ */ jsx(File, {
+		baseName: "sse.ts",
+		path: path.resolve(root, ".kubb/sse.ts"),
+		copy: sse
+	}), footer && /* @__PURE__ */ jsx(File, {
+		baseName: "client.ts",
+		path: path.resolve(root, ".kubb/client.ts"),
+		footer
+	})] });
+}
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -946,13 +1070,24 @@ function resolveOperationTypes(driver, pluginName) {
 * `@kubb/plugin-axios`). Emits one async function per OpenAPI operation using the shared
 * `Operation` component: a grouped `<Name>Request` type and a function that forwards a single
 * `options` object to the bundled `client` and returns the `Unwrappable<RequestResult>`. Only the
-* generator `name` differs between plugins. Every other resolution, import, and rendering step is
-* identical.
+* generator `name` and the runtime templates differ between plugins. Every other resolution, import,
+* and rendering step is identical.
+*
+* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
+* `text/event-stream` operation.
 */
-function createClientGenerator(name) {
+function createClientGenerator(name, { sse } = {}) {
 	return defineGenerator({
 		name,
 		renderer: jsxRenderer,
+		operations(nodes, ctx) {
+			return /* @__PURE__ */ jsx(StreamRuntime, {
+				nodes,
+				root: ctx.root,
+				sse,
+				baseURL: ctx.options.baseURL
+			});
+		},
 		operation(node, ctx) {
 			if (!ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
@@ -1002,19 +1137,19 @@ function createClientGenerator(name) {
 			const clientPath = importPath ?? path.resolve(root, ".kubb/client.ts");
 			const clientRoot = importPath === void 0 ? meta.file.path : void 0;
 			const standardSchemaPath = importPath ?? path.resolve(root, ".kubb/standardSchema.ts");
-			const eventStream = isEventStream(node);
+			const ssePath = importPath ?? path.resolve(root, ".kubb/sse.ts");
+			const stream = getEventStream(node);
 			const clientValueImports = (() => {
-				if (eventStream) return ["client", "toEventStream"];
 				if (returnType === "plain") return ["client"];
 				if (returnType === "data") return ["client", "unwrapResult"];
 				return ["client", "withUnwrap"];
 			})();
 			const clientTypeImports = (() => {
-				if (eventStream) return [
-					"Options",
-					"EventStreamResult",
-					"SuccessOf"
-				];
+				if (stream) return {
+					plain: ["Options", "SuccessOf"],
+					data: ["SuccessOf"],
+					full: ["SuccessOf", "Unwrappable"]
+				}[returnType];
 				if (returnType === "plain") return ["Options", "RequestResult"];
 				if (returnType === "data") return ["Options", "UnwrappedResult"];
 				return [
@@ -1055,6 +1190,20 @@ function createClientGenerator(name) {
 						path: clientPath,
 						isTypeOnly: true
 					}),
+					stream && /* @__PURE__ */ jsx(File.Import, {
+						name: ["toEventStream"],
+						root: clientRoot,
+						path: ssePath
+					}),
+					stream && /* @__PURE__ */ jsx(File.Import, {
+						name: buildEventStreamImports({
+							returnType,
+							typed: stream === "event"
+						}),
+						root: clientRoot,
+						path: ssePath,
+						isTypeOnly: true
+					}),
 					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
 						name: Array.from(new Set(importedTypeNames)),
 						root: meta.file.path,
@@ -1091,43 +1240,26 @@ function createClientGenerator(name) {
 */
 function buildSdkMethod({ node, name, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
 	if (!ast.isHttpOperationNode(node)) return "";
-	const signature = buildGroupedOptionsSignature({
+	const body = buildOperationBody({
 		node,
 		types,
-		returnType,
-		throwOnErrorDefault
-	});
-	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
-		node,
 		validatorHooks,
 		security,
-		throwOnErrorDefault
-	});
-	const eventStreamReturn = eventStream ? buildEventStreamReturn({
-		node,
-		types,
-		callConfig
-	}) : null;
-	const methodReturnType = eventStreamReturn?.returnType ?? signature.returnType;
-	const returnStatement = eventStreamReturn?.statement ?? buildReturnStatement({
-		node,
-		types,
-		callConfig,
 		returnType,
 		throwOnErrorDefault
 	});
-	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
+	const generics = body.generics.length ? `<${body.generics.join(", ")}>` : "";
 	const jsdoc = buildJSDoc(buildOperationComments(node, {
 		link: "urlPath",
 		linkPosition: "beforeDeprecated",
 		splitLines: true
 	}));
 	const methodBody = [
-		mergeContentType ? "const { client: request = this.client, contentType, ...config } = options" : "const { client: request = this.client, ...config } = options",
+		body.mergeContentType ? "const { client: request = this.client, contentType, ...config } = options" : "const { client: request = this.client, ...config } = options",
 		"",
-		returnStatement
+		body.statement
 	].map((line) => line ? `    ${line}` : "").join("\n");
-	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${methodReturnType} {\n${methodBody}\n  }`;
+	return `${jsdoc}  public ${name}${generics}(${body.paramsSignature}): ${body.returnType} {\n${methodBody}\n  }`;
 }
 /**
 * Renders one instance class per tag with one method per operation. The constructor takes a client
@@ -1283,8 +1415,11 @@ function collectImportsByFile(ops, pick) {
 * emits one class per tag and, when `sdk.name` is set, a composed root that instantiates every tag
 * client. With `sdk.mode: 'flat'` it emits one class named by `sdk.name`, with every operation as a
 * direct method.
+*
+* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
+* `text/event-stream` operation.
 */
-function createSdkGenerator() {
+function createSdkGenerator({ sse } = {}) {
 	return defineGenerator({
 		name: "sdk",
 		renderer: jsxRenderer,
@@ -1305,6 +1440,7 @@ function createSdkGenerator() {
 			const controllers = buildControllers(nodes, ctx, types, validatorEnabled);
 			const clientPath = path.resolve(root, ".kubb/client.ts");
 			const standardSchemaPath = path.resolve(root, ".kubb/standardSchema.ts");
+			const ssePath = path.resolve(root, ".kubb/sse.ts");
 			const banner = (file) => resolver.default.banner(ctx.meta, {
 				output,
 				config,
@@ -1333,7 +1469,8 @@ function createSdkGenerator() {
 					namesByPath: /* @__PURE__ */ new Map(),
 					filesByPath: /* @__PURE__ */ new Map()
 				};
-				const hasEventStream = ops.some((op) => isEventStream(op.node));
+				const shapes = new Set(ops.map((op) => getEventStream(op.node)).filter(Boolean));
+				const hasEventStream = shapes.size > 0;
 				const hasResult = ops.some((op) => !isEventStream(op.node));
 				return /* @__PURE__ */ jsxs(File, {
 					baseName: file.baseName,
@@ -1343,11 +1480,7 @@ function createSdkGenerator() {
 					footer: footer(file),
 					children: [
 						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"createClient",
-								...hasResult ? [returnType === "data" ? "unwrapResult" : "withUnwrap"] : [],
-								...hasEventStream ? ["toEventStream"] : []
-							],
+							name: ["createClient", returnType === "data" ? "unwrapResult" : "withUnwrap"],
 							root: file.path,
 							path: clientPath
 						}),
@@ -1356,13 +1489,28 @@ function createSdkGenerator() {
 								"ClientConfig",
 								"ClientInstance",
 								"Options",
-								...hasResult ? returnType === "data" ? ["UnwrappedResult"] : ["Unwrappable", "RequestResult"] : [],
-								...hasEventStream ? ["EventStreamResult", "SuccessOf"] : []
+								...returnType === "data" ? [] : ["Unwrappable"],
+								...hasResult ? [returnType === "data" ? "UnwrappedResult" : "RequestResult"] : [],
+								...hasEventStream ? ["SuccessOf"] : []
 							],
 							root: file.path,
 							path: clientPath,
 							isTypeOnly: true
 						}),
+						hasEventStream && /* @__PURE__ */ jsx(File.Import, {
+							name: ["toEventStream"],
+							root: file.path,
+							path: ssePath
+						}),
+						hasEventStream && /* @__PURE__ */ jsx(File.Import, {
+							name: buildEventStreamImports({
+								returnType,
+								typed: shapes.has("event")
+							}),
+							root: file.path,
+							path: ssePath,
+							isTypeOnly: true
+						}),
 						validator === "zod" && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
 							name: ["z"],
 							path: "zod",
@@ -1393,61 +1541,66 @@ function createSdkGenerator() {
 					]
 				}, file.path);
 			};
-			if (sdk.mode === "flat") return renderClassFile(resolver.className(sdk.name ?? "sdk"), resolver.file({
+			const renderFacadeFile = (name) => {
+				const sdkFile = resolver.file({
+					name,
+					extname: ".ts",
+					root,
+					output,
+					group: group ?? void 0
+				});
+				const members = controllers.map(({ name, tag }) => ({
+					className: name,
+					propName: resolver.propertyName(tag ?? name)
+				}));
+				return /* @__PURE__ */ jsxs(File, {
+					baseName: sdkFile.baseName,
+					path: sdkFile.path,
+					meta: sdkFile.meta,
+					banner: banner(sdkFile),
+					footer: footer(sdkFile),
+					children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["ClientConfig"],
+							root: sdkFile.path,
+							path: clientPath,
+							isTypeOnly: true
+						}),
+						controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
+							name: [name],
+							root: sdkFile.path,
+							path: file.path
+						}, name)),
+						/* @__PURE__ */ jsx(SdkFacade, {
+							name: resolver.className(name),
+							members
+						})
+					]
+				}, sdkFile.path);
+			};
+			const files = sdk.mode === "flat" ? renderClassFile(resolver.className(sdk.name ?? "sdk"), resolver.file({
 				name: sdk.name ?? "sdk",
 				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
-			}), controllers.flatMap((controller) => controller.operations));
-			const classFiles = controllers.map(({ name, file, operations: ops }) => renderClassFile(name, file, ops));
-			if (!sdk.name) return /* @__PURE__ */ jsx(Fragment, { children: classFiles });
-			const sdkFile = resolver.file({
-				name: sdk.name,
-				extname: ".ts",
+			}), controllers.flatMap((controller) => controller.operations)) : [...controllers.map(({ name, file, operations: ops }) => renderClassFile(name, file, ops)), sdk.name && renderFacadeFile(sdk.name)];
+			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(StreamRuntime, {
+				nodes,
 				root,
-				output,
-				group: group ?? void 0
-			});
-			const facadeName = resolver.className(sdk.name);
-			const members = controllers.map(({ name, tag }) => ({
-				className: name,
-				propName: resolver.propertyName(tag ?? name)
-			}));
-			return /* @__PURE__ */ jsxs(Fragment, { children: [classFiles, /* @__PURE__ */ jsxs(File, {
-				baseName: sdkFile.baseName,
-				path: sdkFile.path,
-				meta: sdkFile.meta,
-				banner: banner(sdkFile),
-				footer: footer(sdkFile),
-				children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["ClientConfig"],
-						root: sdkFile.path,
-						path: clientPath,
-						isTypeOnly: true
-					}),
-					controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
-						name: [name],
-						root: sdkFile.path,
-						path: file.path
-					}, name)),
-					/* @__PURE__ */ jsx(SdkFacade, {
-						name: facadeName,
-						members
-					})
-				]
-			}, sdkFile.path)] });
+				sse,
+				baseURL: ctx.options.baseURL
+			}), files] });
 		}
 	});
 }
 // ../../internals/client/src/macros.ts
 /**
-* Macros the client plugins apply by default, ahead of any user macros. `macroSimplifyUnion`
-* drops union members a broader scalar already covers, keeping the generated response and error
+* Macros the client plugins apply by default, ahead of any user macros. `macroDedupeUnion`
+* drops repeated union members, keeping the generated response and error
 * unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
 */
-const defaultMacros = [macroSimplifyUnion];
+const defaultMacros = [macroDedupeUnion];
 // ../../internals/client/src/resolver.ts
 /**
 * Default resolver shared by the client plugins. Functions use safe camelCase identifiers and
@@ -1472,30 +1625,32 @@ const resolverClient = createResolver({
 		return ensureValidVarName(camelCase(name));
 	}
 });
+// src/templates.ts
+const require = createRequire(import.meta.url);
+/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
+const fetchClientTemplatePath = fileURLToPath(new URL("../templates/client.ts", import.meta.url));
+/**
+* Absolute paths to the runtime templates `@kubb/plugin-client` ships for every client plugin, copied into `.kubb/core.ts`,
+* `.kubb/serializers.ts`, `.kubb/standardSchema.ts`, and `.kubb/sse.ts`.
+*/
+const coreTemplatePath = require.resolve("@kubb/plugin-client/templates/core.ts");
+const serializersTemplatePath = require.resolve("@kubb/plugin-client/templates/serializers.ts");
+const standardSchemaTemplatePath = require.resolve("@kubb/plugin-client/templates/standardSchema.ts");
+const sseTemplatePath = require.resolve("@kubb/plugin-client/templates/sse.ts");
 // src/generators/clientGenerator.tsx
 /**
 * Built-in operation generator for `@kubb/plugin-fetch`. Emits one async function per OpenAPI
 * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
 * that forwards a single `options` object to the bundled `client` and returns the `RequestResult`.
 */
-const clientGenerator = createClientGenerator("fetch");
+const clientGenerator = createClientGenerator("fetch", { sse: sseTemplatePath });
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.14.6",
+	"kubb": ">=5.16.0",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.13.0-canary.20261105T105941";
-// src/templates.ts
-/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
-const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.ts", import.meta.url));
-/** Absolute path to the fetch serializers template, copied into `.kubb/serializers.ts`. */
-const fetchSerializersTemplatePath = fileURLToPath(new URL("../templates/serializers.ts", import.meta.url));
-/**
-* Absolute path to the Standard Schema runtime template. Pass it to a file node's `copy` field to
-* emit the helper into the generated `.kubb/standardSchema.ts` verbatim.
-*/
-const standardSchemaTemplatePath = fileURLToPath(new URL("../templates/standardSchema.ts", import.meta.url));
+var version = "5.13.0";
 // src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
@@ -1559,19 +1714,22 @@ const pluginFetch = defineExtension({
 		};
 		setResolver(resolved.resolver);
 		setMacros([...defaultMacros, ...options.macros ?? []]);
-		addGenerator(resolved.sdk ? createSdkGenerator() : clientGenerator);
+		addGenerator(resolved.sdk ? createSdkGenerator({ sse: sseTemplatePath }) : clientGenerator);
 		const root = path.resolve(config.root, config.output.path);
-		const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
 		injectFile({
 			baseName: "serializers.ts",
 			path: path.resolve(root, ".kubb/serializers.ts"),
-			copy: fetchSerializersTemplatePath
+			copy: serializersTemplatePath
+		});
+		injectFile({
+			baseName: "core.ts",
+			path: path.resolve(root, ".kubb/core.ts"),
+			copy: coreTemplatePath
 		});
 		injectFile({
 			baseName: "client.ts",
 			path: path.resolve(root, ".kubb/client.ts"),
-			copy: fetchClientTemplatePath,
-			footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : void 0
+			copy: fetchClientTemplatePath
 		});
 		injectFile({
 			baseName: "standardSchema.ts",