@kizunajs/fetch 2.0.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,263 @@
+import { buildPath, isProblemDetails, isRouteDefinition, isStreamResponse, isValidationError, streamMode } from "kizunajs";
+//#region src/sse.ts
+const parseData = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+const findLineEnd = (buffer, final) => {
+	for (let index = 0; index < buffer.length; index += 1) {
+		const character = buffer[index];
+		if (character === "\n") return {
+			index,
+			length: 1
+		};
+		if (character === "\r") {
+			if (index + 1 < buffer.length) return {
+				index,
+				length: buffer[index + 1] === "\n" ? 2 : 1
+			};
+			if (final) return {
+				index,
+				length: 1
+			};
+			return;
+		}
+	}
+};
+/**
+* Parses `text/event-stream` per the WHATWG HTML specification.
+*/
+async function* parseServerSentEvents(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let first = true;
+	let dataLines = [];
+	let eventType = "";
+	let lastEventId = "";
+	let retry;
+	const dispatch = () => {
+		if (dataLines.length === 0) {
+			eventType = "";
+			return;
+		}
+		const message = { data: parseData(dataLines.join("\n")) };
+		if (eventType !== "") message.event = eventType;
+		if (lastEventId !== "") message.id = lastEventId;
+		if (retry !== void 0) message.retry = retry;
+		dataLines = [];
+		eventType = "";
+		retry = void 0;
+		return message;
+	};
+	const processLine = (line) => {
+		if (line === "") return dispatch();
+		if (line.startsWith(":")) return void 0;
+		const separator = line.indexOf(":");
+		const field = separator === -1 ? line : line.slice(0, separator);
+		let value = separator === -1 ? "" : line.slice(separator + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		switch (field) {
+			case "event":
+				eventType = value;
+				break;
+			case "data":
+				dataLines.push(value);
+				break;
+			case "id":
+				if (!value.includes("\0")) lastEventId = value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(value)) retry = Number(value);
+				break;
+		}
+	};
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			let chunk = done ? decoder.decode() : decoder.decode(value, { stream: true });
+			if (first && chunk.length > 0) {
+				if (chunk.charCodeAt(0) === 65279) chunk = chunk.slice(1);
+				first = false;
+			}
+			buffer += chunk;
+			for (;;) {
+				const lineEnd = findLineEnd(buffer, done);
+				if (lineEnd === void 0) break;
+				const line = buffer.slice(0, lineEnd.index);
+				buffer = buffer.slice(lineEnd.index + lineEnd.length);
+				const message = processLine(line);
+				if (message !== void 0) yield message;
+			}
+			if (done) return;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+async function* readTextChunks(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) {
+				const tail = decoder.decode();
+				if (tail.length > 0) yield tail;
+				return;
+			}
+			const text = decoder.decode(value, { stream: true });
+			if (text.length > 0) yield text;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+async function* readByteChunks(body) {
+	const reader = body.getReader();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return;
+			yield value;
+		}
+	} finally {
+		reader.cancel().catch(() => void 0);
+	}
+}
+//#endregion
+//#region src/client.ts
+const buildFormData = (body) => {
+	const formData = new FormData();
+	for (const [key, entry] of Object.entries(body)) {
+		const values = Array.isArray(entry) ? entry : [entry];
+		for (const value of values) if (value instanceof File || value instanceof Blob) formData.append(key, value);
+		else if (value !== void 0 && value !== null) formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+	}
+	return formData;
+};
+/**
+* Serializes a query or path value for the URL. Dates use ISO 8601; everything
+* else uses `String`.
+*/
+const serializeValue = (value) => value instanceof Date ? value.toISOString() : String(value);
+const buildQueryString = (query) => {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) for (const item of value) params.append(key, serializeValue(item));
+		else params.append(key, serializeValue(value));
+	}
+	const result = params.toString();
+	return result.length > 0 ? `?${result}` : "";
+};
+const CLIENT_ROUTE = Symbol.for("kizuna.client-route");
+/**
+* The route a client method answers, or `undefined` for anything that is not
+* one.
+*/
+const routeOf = (value) => typeof value === "function" ? value[CLIENT_ROUTE] : void 0;
+const buildRouteFn = (route, config) => {
+	const call = async (args = {}) => {
+		const url = config.baseUrl + buildPath(route.path, args.params) + (args.query ? buildQueryString(args.query) : "");
+		const headers = {
+			...config.baseHeaders ?? {},
+			...args.headers ?? {}
+		};
+		let body;
+		if (args.body !== void 0) {
+			const hasContentTypeHeader = "Content-Type" in headers || "content-type" in headers;
+			switch (route.contentType) {
+				case "multipart/form-data":
+					body = args.body instanceof FormData ? args.body : buildFormData(args.body);
+					break;
+				case "application/x-www-form-urlencoded":
+					if (!hasContentTypeHeader) headers["Content-Type"] = "application/x-www-form-urlencoded";
+					body = new URLSearchParams(args.body);
+					break;
+				default:
+					if (!hasContentTypeHeader) headers["Content-Type"] = "application/json";
+					body = JSON.stringify(args.body);
+			}
+		}
+		const requestHeaders = new Headers(headers);
+		if (config.onRequest) await config.onRequest({
+			url,
+			method: route.method,
+			headers: requestHeaders,
+			route
+		});
+		const res = await (config.fetch ?? fetch)(url, {
+			method: route.method,
+			headers: requestHeaders,
+			body,
+			credentials: config.credentials,
+			...args.fetchOptions
+		});
+		const responseHeaders = {};
+		res.headers.forEach((value, key) => {
+			responseHeaders[key] = value;
+		});
+		const responseSpec = route.responses[res.status];
+		if (isStreamResponse(responseSpec) && res.body !== null) return {
+			status: res.status,
+			body: readStream(res.body, responseSpec),
+			headers: responseHeaders
+		};
+		const text = await res.text();
+		let parsed;
+		try {
+			parsed = text.length > 0 ? JSON.parse(text) : void 0;
+		} catch {
+			parsed = text;
+		}
+		return {
+			status: res.status,
+			body: parsed,
+			headers: responseHeaders
+		};
+	};
+	call[CLIENT_ROUTE] = route;
+	return call;
+};
+const readStream = (body, definition) => {
+	switch (streamMode(definition)) {
+		case "events": return parseServerSentEvents(body);
+		case "text": return readTextChunks(body);
+		case "binary": return readByteChunks(body);
+	}
+};
+const buildClientTree = (router, config) => {
+	const result = {};
+	for (const key of Object.keys(router)) {
+		const node = router[key];
+		if (isRouteDefinition(node)) result[key] = buildRouteFn(node, config);
+		else if (node && typeof node === "object") result[key] = buildClientTree(node, config);
+	}
+	return result;
+};
+/**
+* Folds the request context headers into `baseHeaders`, so every request
+* carries them. An explicit `baseHeaders` entry wins.
+*/
+const withContextHeaders = (config) => {
+	const contextHeaders = config.requestContext;
+	if (!contextHeaders) return config;
+	return {
+		...config,
+		baseHeaders: {
+			...Object.fromEntries(Object.entries(contextHeaders).filter(([, value]) => value !== void 0)),
+			...config.baseHeaders ?? {}
+		}
+	};
+};
+/**
+* Builds the client tree a generated client exposes. The generated file owns the
+* types; this owns the requests.
+*/
+const createGeneratedClient = (routes, config) => buildClientTree(routes, withContextHeaders(config));
+//#endregion
+export { CLIENT_ROUTE, createGeneratedClient, isProblemDetails, isValidationError, routeOf };

package/dist/server.cjs

@@ -0,0 +1,437 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let kizunajs_schemas = require("kizunajs/schemas");
+let kizunajs_generator = require("kizunajs/generator");
+//#region src/zod-to-typescript.ts
+/**
+* Collects the named types a walk produces, so a model shared by many routes is
+* declared once.
+*/
+var TypeCollector = class {
+	named = /* @__PURE__ */ new Map();
+	claimed = /* @__PURE__ */ new Set();
+	/**
+	* Claims a name before its body is walked, so a model that refers to itself
+	* resolves to its own name instead of recursing. Answers whether the caller
+	* is the one that has to emit it.
+	*/
+	claim(name) {
+		if (this.claimed.has(name)) return false;
+		this.claimed.add(name);
+		return true;
+	}
+	add(type) {
+		this.named.set(type.name, type);
+	}
+	all() {
+		return [...this.named.values()].sort((left, right) => left.name.localeCompare(right.name));
+	}
+};
+const quote = (value) => JSON.stringify(value);
+const indent$1 = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
+/**
+* A property name, quoted only when it is not a plain identifier.
+*/
+const propertyKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : quote(key);
+/**
+* A doc comment over the lines it is given, or nothing when there are none.
+* Always multi-line, the way the rest of this repository writes them.
+*/
+const docComment = (lines) => {
+	const body = lines.flatMap((line) => line.split("\n"));
+	if (body.length === 0) return "";
+	return `/**\n${body.map((line) => ` * ${line}`.trimEnd()).join("\n")}\n */\n`;
+};
+/**
+* Renders a declared example as the TypeScript literal a caller would write.
+*/
+const exampleLiteral = (value) => {
+	if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+	if (value === void 0) return "undefined";
+	return JSON.stringify(value) ?? "undefined";
+};
+const STRING_SAMPLES = {
+	email: "ada@example.com",
+	url: "https://example.com",
+	uuid: "3f1c2d9e-5b6a-4c7d-8e9f-0a1b2c3d4e5f",
+	datetime: "2026-01-01T00:00:00Z",
+	date: "2026-01-01",
+	time: "00:00:00"
+};
+const stringSample = (schema, key) => {
+	const def = (0, kizunajs_generator.readDef)(schema);
+	const formats = [def.format, ...(def.checks ?? []).map((check) => check.format ?? check.def?.format)];
+	for (const format of formats) if (format !== void 0 && format in STRING_SAMPLES) return exampleLiteral(STRING_SAMPLES[format]);
+	if (key !== void 0 && /id$/i.test(key)) return exampleLiteral("1");
+	return exampleLiteral("string");
+};
+/**
+* A value a caller could pass for a schema, used in the `@example` on each
+* client method. A schema that declares an example is taken at its word;
+* anything else gets a value of the right shape.
+*/
+const sampleValue = (schema, depth = 0, key) => {
+	const [declared] = (0, kizunajs_generator.readMetaExamples)(schema);
+	if (declared !== void 0) return exampleLiteral(declared);
+	if ((0, kizunajs_generator.isFileSchema)(schema)) return "new File([], 'upload.txt')";
+	if ((0, kizunajs_generator.isBinarySchema)(schema)) return "new Uint8Array()";
+	const def = (0, kizunajs_generator.readDef)(schema);
+	if (def.type === "default" && def.defaultValue !== void 0) return exampleLiteral(def.defaultValue);
+	if (def.type === "pipe") {
+		const side = def.out ?? def.in;
+		return side ? sampleValue(side, depth, key) : "undefined";
+	}
+	if (def.innerType && def.type !== "object") return sampleValue(def.innerType, depth, key);
+	switch (def.type) {
+		case "number":
+		case "int": return "1";
+		case "bigint": return "1n";
+		case "boolean": return "true";
+		case "date": return exampleLiteral("2026-01-01");
+		case "null": return "null";
+		case "literal": return def.values?.length ? exampleLiteral(def.values[0]) : "undefined";
+		case "enum": {
+			const [first] = Object.values(def.entries ?? {});
+			return first === void 0 ? "undefined" : exampleLiteral(first);
+		}
+		case "array":
+			if (!def.element || depth >= SAMPLE_DEPTH) return "[]";
+			return `[\n${indent$1(`${sampleValue(def.element, depth + 1, key)},`)}\n]`;
+		case "object": return sampleObject(schema, depth);
+		case "record": return "{}";
+		case "union": {
+			const options = (0, kizunajs_generator.readDiscriminatedUnion)(schema)?.options ?? def.options ?? [];
+			return options[0] ? sampleValue(options[0], depth, key) : "undefined";
+		}
+		case "string": return stringSample(schema, key);
+		default: return "undefined";
+	}
+};
+const SAMPLE_DEPTH = 2;
+/**
+* The required fields of an object schema, written as the literal a caller
+* would pass. Optional fields are left out, since an example shows the least
+* the route needs.
+*/
+const sampleObject = (schema, depth = 0) => {
+	const shape = (0, kizunajs_generator.readObjectShape)(schema);
+	if (!shape) return "{}";
+	const required = Object.entries(shape).filter(([, field]) => !(0, kizunajs_generator.unwrapOptionalWrappers)(field).optional);
+	if (required.length === 0 || depth >= SAMPLE_DEPTH) return "{}";
+	return `{\n${indent$1(required.map(([key, field]) => `${propertyKey(key)}: ${sampleValue((0, kizunajs_generator.unwrapOptionalWrappers)(field).inner, depth + 1, key)},`).join("\n"))}\n}`;
+};
+/**
+* What an editor shows above a field: its description, whether it is on its way
+* out, and the values the schema declares as examples.
+*/
+const fieldDoc = (field) => {
+	const lines = [];
+	const description = (0, kizunajs_generator.readMetaDescription)(field);
+	if (description !== void 0) lines.push(description);
+	const deprecation = (0, kizunajs_generator.readDeprecation)(field);
+	if (deprecation !== void 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push(`@deprecated ${deprecation.message ?? ""}`.trimEnd());
+	}
+	for (const example of (0, kizunajs_generator.readMetaExamples)(field)) {
+		if (lines.length > 0) lines.push("");
+		lines.push("@example", exampleLiteral(example));
+	}
+	return lines;
+};
+const objectBody = (schema, collector, hint) => {
+	const shape = (0, kizunajs_generator.readObjectShape)(schema);
+	if (!shape) return "Record<string, unknown>";
+	const entries = Object.entries(shape);
+	if (entries.length === 0) return "Record<string, never>";
+	return `{\n${indent$1(entries.map(([key, field]) => {
+		const doc = docComment(fieldDoc(field));
+		const mark = (0, kizunajs_generator.unwrapOptionalWrappers)(field).optional ? "?" : "";
+		return `${doc}${propertyKey(key)}${mark}: ${typeOf(field, collector, `${hint}${(0, kizunajs_generator.toPascalCase)(key)}`)};`;
+	}).join("\n"))}\n}`;
+};
+/**
+* The TypeScript type a schema describes. Named models are collected and
+* referenced; anonymous shapes are inlined.
+*/
+const typeOf = (schema, collector, hint) => {
+	if ((0, kizunajs_generator.isFileSchema)(schema)) return "File | Blob";
+	if ((0, kizunajs_generator.isBinarySchema)(schema)) return "Uint8Array";
+	const def = (0, kizunajs_generator.readDef)(schema);
+	if (def.type === "nullable" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
+	if (def.type === "nullish" && def.innerType) return `${typeOf(def.innerType, collector, hint)} | null`;
+	if (def.innerType && def.type !== "object") {
+		const { inner } = (0, kizunajs_generator.unwrapOptionalWrappers)(schema);
+		if (inner !== schema) return typeOf(inner, collector, hint);
+		return typeOf(def.innerType, collector, hint);
+	}
+	if (def.type === "pipe") {
+		const side = def.out ?? def.in;
+		return side ? typeOf(side, collector, hint) : "unknown";
+	}
+	const modelName = (0, kizunajs_generator.readMetaId)(schema);
+	if (modelName !== void 0 && def.type === "object") {
+		if (collector.claim(modelName)) collector.add({
+			name: modelName,
+			description: (0, kizunajs_generator.readMetaDescription)(schema),
+			body: objectBody(schema, collector, modelName)
+		});
+		return modelName;
+	}
+	switch (def.type) {
+		case "string": return "string";
+		case "number":
+		case "int": return "number";
+		case "bigint": return "string";
+		case "boolean": return "boolean";
+		case "date": return "string";
+		case "null": return "null";
+		case "any":
+		case "unknown": return "unknown";
+		case "never": return "never";
+		case "void":
+		case "undefined": return "undefined";
+		case "literal": {
+			const values = def.values ?? [];
+			return values.length > 0 ? values.map((value) => quote(String(value))).join(" | ") : "never";
+		}
+		case "enum": {
+			const values = Object.values(def.entries ?? {});
+			return values.length > 0 ? values.map((value) => quote(String(value))).join(" | ") : "never";
+		}
+		case "array": return def.element ? `Array<${typeOf(def.element, collector, `${hint}Item`)}>` : "unknown[]";
+		case "object": return objectBody(schema, collector, hint);
+		case "record": return `Record<string, ${def.valueType ? typeOf(def.valueType, collector, `${hint}Value`) : "unknown"}>`;
+		case "union": {
+			const options = (0, kizunajs_generator.readDiscriminatedUnion)(schema)?.options ?? def.options ?? [];
+			if (options.length === 0) return "unknown";
+			return options.map((option, index) => typeOf(option, collector, `${hint}${index}`)).join(" | ");
+		}
+		default: return "unknown";
+	}
+};
+//#endregion
+//#region src/generator.ts
+const indent = (text, depth = 1) => text.split("\n").map((line) => line.length > 0 ? "    ".repeat(depth) + line : line).join("\n");
+const pathParamNames = (path) => [...path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1] ?? "");
+/**
+* One server-sent event, typed from what the response declares. A record of
+* event name to schema becomes a union discriminated on `event`; a single
+* schema is the only shape a message takes.
+*/
+const eventUnion = (stream, collector, namespace) => {
+	const frame = "id?: string; retry?: number";
+	if (stream && typeof stream === "object" && !("_zod" in stream) && !("_def" in stream)) {
+		const arms = Object.entries(stream).map(([event, schema]) => `{ event: '${event}'; data: ${typeOf(schema, collector, `${namespace}${(0, kizunajs_generator.toPascalCase)(event)}`)}; ${frame} }`);
+		return arms.length > 0 ? arms.join(" | ") : `{ event?: string; data: string; ${frame} }`;
+	}
+	return `{ event?: string; data: ${typeOf(stream, collector, `${namespace}Message`)}; ${frame} }`;
+};
+const streamBody = (mode, stream, collector, namespace) => {
+	if (mode === "binary") return "AsyncIterable<Uint8Array>";
+	if (mode === "text") return "AsyncIterable<string>";
+	return `AsyncIterable<${eventUnion(stream, collector, namespace)}>`;
+};
+/**
+* The call a route's `@example` shows: the arguments it cannot be called
+* without, filled with values of the shape each schema declares.
+*/
+const exampleCall = (routeKey, route) => {
+	const entries = [];
+	const params = pathParamNames(route.path);
+	if (params.length > 0) {
+		const shape = route.pathParams ? (0, kizunajs_generator.readObjectShape)(route.pathParams) : void 0;
+		const fields = params.map((name) => {
+			const declared = shape?.[name];
+			return `${name}: ${declared ? sampleValue(declared, 0, name) : "'1'"},`;
+		});
+		entries.push(`params: {\n${indent(fields.join("\n"))}\n},`);
+	}
+	if (route.query && requiresArgument(route.query)) entries.push(`query: ${sampleObject(route.query)},`);
+	if (route.body && requiresArgument(route.body)) entries.push(`body: ${sampleValue(route.body)},`);
+	return `const result = await client.${routeKey}(${entries.length > 0 ? `{\n${indent(entries.join("\n"))}\n}` : ""});`;
+};
+/**
+* Whether a schema has anything a caller has to pass, so a route whose query is
+* every-field-optional keeps its example to the call itself.
+*/
+const requiresArgument = (schema) => {
+	const shape = (0, kizunajs_generator.readObjectShape)(schema);
+	if (!shape) return true;
+	return Object.values(shape).some((field) => !(0, kizunajs_generator.unwrapOptionalWrappers)(field).optional);
+};
+/**
+* What an editor shows above a client method: what the route is for, whether it
+* is on its way out, and how it is called.
+*/
+const routeDoc = (routeKey, route) => {
+	const lines = [];
+	if (route.summary) lines.push(route.summary);
+	if (route.description) {
+		if (lines.length > 0) lines.push("");
+		lines.push(route.description);
+	}
+	if (route.deprecated !== void 0 && route.deprecated !== false) {
+		const message = typeof route.deprecated === "string" ? route.deprecated : typeof route.deprecated === "object" ? route.deprecated.message : void 0;
+		if (lines.length > 0) lines.push("");
+		lines.push(`@deprecated ${message ?? ""}`.trimEnd());
+	}
+	if (lines.length > 0) lines.push("");
+	lines.push("@example", exampleCall(routeKey, route));
+	return docComment(lines);
+};
+const emitRoute = (routeKey, key, route, collector) => {
+	const namespace = routeKey.split(".").map(kizunajs_generator.toPascalCase).join("");
+	const members = [];
+	const args = [];
+	const params = pathParamNames(route.path);
+	if (params.length > 0) {
+		const body = route.pathParams ? typeOf(route.pathParams, collector, `${namespace}Params`) : `{\n${indent(params.map((name) => `${name}: string;`).join("\n"))}\n}`;
+		members.push(`export type Params = ${body};`);
+		args.push(`params: API.${namespace}.Params`);
+	}
+	if (route.query) {
+		members.push(`export type Query = ${typeOf(route.query, collector, `${namespace}Query`)};`);
+		args.push(`query?: API.${namespace}.Query`);
+	}
+	if (route.body) {
+		members.push(`export type Body = ${typeOf(route.body, collector, `${namespace}Body`)};`);
+		args.push(`body: API.${namespace}.Body`);
+	}
+	if (route.headers) {
+		members.push(`export type Headers = ${typeOf(route.headers, collector, `${namespace}Headers`)};`);
+		args.push(`headers?: API.${namespace}.Headers`);
+	} else args.push("headers?: Record<string, string>");
+	args.push("fetchOptions?: RequestInit");
+	const validates = route.body !== void 0 || route.query !== void 0;
+	const declaredBadRequest = Object.keys(route.responses).includes("400");
+	const validationBody = validates ? typeOf(kizunajs_schemas.ValidationErrorSchema, collector, "ValidationError") : void 0;
+	const results = Object.entries(route.responses).map(([status, response]) => {
+		const headers = (0, kizunajs_generator.resolveResponseHeaders)(response);
+		const headerType = headers ? typeOf(headers, collector, `${namespace}${status}Headers`) : "Record<string, string>";
+		if ((0, kizunajs_generator.isStreamResponse)(response)) return `{ status: ${status}; body: ${streamBody((0, kizunajs_generator.streamContentType)(response).includes("event-stream") ? "events" : (0, kizunajs_generator.streamContentType)(response).startsWith("text/") ? "text" : "binary", response.stream, collector, `${namespace}${status}`)}; headers: ${headerType} }`;
+		const schema = (0, kizunajs_generator.resolveResponseBody)(response);
+		const body = schema ? typeOf(schema, collector, `${namespace}${status}`) : "undefined";
+		return `{ status: ${status}; body: ${status === "400" && validationBody ? `${body} | ${validationBody}` : body}; headers: ${headerType} }`;
+	});
+	if (validationBody && !declaredBadRequest) results.push(`{ status: 400; body: ${validationBody}; headers: Record<string, string> }`);
+	members.push(`export type Result =\n${indent(results.map((result) => `| ${result}`).join("\n"))};`);
+	const argsType = `{\n${indent(args.map((arg) => `${arg};`).join("\n"))}\n}`;
+	const tableEntries = [`method: '${route.method}'`, `path: '${route.path}'`];
+	if (route.contentType) tableEntries.push(`contentType: '${route.contentType}'`);
+	const responses = Object.entries(route.responses).map(([status, response]) => (0, kizunajs_generator.isStreamResponse)(response) ? `${status}: { stream: { contentType: '${(0, kizunajs_generator.streamContentType)(response)}' } }` : `${status}: {}`);
+	tableEntries.push(`responses: {\n${indent(responses.map((entry) => `${entry},`).join("\n"))}\n}`);
+	const streams = Object.values(route.responses).some((response) => (0, kizunajs_generator.isStreamResponse)(response));
+	return {
+		namespace,
+		signature: `${routeDoc(routeKey, route)}${key}: ClientMethod<'${route.method}', ${streams}, ${argsType}, API.${namespace}.Result>;`,
+		declaration: `export namespace ${namespace} {\n${indent(members.join("\n\n"))}\n}`,
+		table: `${key}: {\n${indent(tableEntries.map((entry) => `${entry},`).join("\n"))}\n},`
+	};
+};
+const isRoute = (value) => !!value && typeof value === "object" && typeof value.method === "string";
+const emitTree = (routes, prefix, collector) => {
+	const signatures = [];
+	const tables = [];
+	const declarations = [];
+	for (const key of Object.keys(routes)) {
+		const node = routes[key];
+		const routeKey = prefix ? `${prefix}.${key}` : key;
+		if (isRoute(node)) {
+			const emitted = emitRoute(routeKey, key, node, collector);
+			signatures.push(emitted.signature);
+			tables.push(emitted.table);
+			declarations.push(emitted.declaration);
+			continue;
+		}
+		if (node && typeof node === "object") {
+			const group = emitTree(node, routeKey, collector);
+			signatures.push(`${key}: {\n${indent(group.signatures)}\n};`);
+			tables.push(`${key}: {\n${indent(group.table)}\n},`);
+			declarations.push(...group.declarations);
+		}
+	}
+	return {
+		signatures: signatures.join("\n"),
+		table: tables.join("\n"),
+		declarations
+	};
+};
+/**
+* Renders a TypeScript client from an api: its named types, the route table
+* the runtime reads, and a `createClient` typed against both.
+*/
+/**
+* The headers a request context declares, as one interface the caller fills
+* once. Absent when the API declares no request context that reads headers.
+*/
+const emitRequestContext = (contract, collector) => {
+	const declarations = Object.values(contract.requestContext ?? {});
+	const fields = [];
+	for (const declaration of declarations) {
+		const headers = declaration.headers;
+		if (!headers) continue;
+		const inner = typeOf(headers, collector, "RequestContext").trim().replace(/^\{/, "").replace(/\}$/, "").split("\n").map((line) => line.trim()).filter((line) => line !== "").join("\n");
+		if (inner !== "") fields.push(inner);
+	}
+	return fields.length > 0 ? `export interface RequestContext {\n${indent(fields.join("\n"))}\n}` : void 0;
+};
+const generateFetchClient = (contract, options = {}) => {
+	const { runtimeModule = "@kizunajs/fetch", regenerateCommand = "kizuna generate", source } = options;
+	const collector = new TypeCollector();
+	const tree = emitTree(contract.routes, "", collector);
+	const api = [...collector.all().map((model) => {
+		return `${model.description ? `/**\n * ${model.description}\n */\n` : ""}export type ${model.name} = ${model.body};`;
+	}), ...tree.declarations].join("\n\n");
+	const requestContext = emitRequestContext(contract, collector);
+	return `/* eslint-disable */
+/**
+${[
+		" * Generated by @kizunajs/fetch. Do not edit.",
+		" *",
+		...source === void 0 ? [] : [` * Source: ${source}`],
+		` * Regenerate: ${regenerateCommand}`
+	].join("\n")}
+ */
+import { createGeneratedClient, type ClientConfig, type ClientMethod, type GeneratedRoutes } from '${runtimeModule}';
+
+export namespace API {
+${indent(api)}
+}
+
+export interface Client {
+${indent(tree.signatures)}
+}
+
+const routes: GeneratedRoutes = {
+${indent(tree.table)}
+};
+
+${requestContext === void 0 ? `/**
+ * A client for this API. Pass the base URL and anything else the runtime takes.
+ */
+export const createClient = (config: ClientConfig): Client => createGeneratedClient(routes, config) as unknown as Client;` : `${requestContext}
+
+/**
+ * A client for this API. Pass the base URL, the request context headers this
+ * API declares, and anything else the runtime takes.
+ */
+export const createClient = (config: ClientConfig & { requestContext?: RequestContext }): Client =>
+    createGeneratedClient(routes, config) as unknown as Client;`}
+`;
+};
+//#endregion
+//#region src/client-target.ts
+/**
+* A TypeScript client target for `kizuna.config.ts`.
+*
+* @example
+* fetchClient({ output: './packages/api-client/src/generated.ts' });
+*/
+const fetchClient = ({ output, ...options }) => ({
+	kind: "fetch",
+	output,
+	generate: (contract) => generateFetchClient(contract, options)
+});
+//#endregion
+exports.fetchClient = fetchClient;
+exports.generateFetchClient = generateFetchClient;