@kizunajs/swift 2.0.0-beta.2 → 2.0.0-beta.20

package/README.md

@@ -10,8 +10,24 @@ pnpm add -D @kizunajs/swift
 
 ## Usage
 
+Name the client in your config, and `kizuna generate` writes it with the rest:
+
+```ts
+import { swiftClient } from '@kizunajs/swift';
+
+export default defineConfig({
+    routes,
+    clients: [
+        swiftClient({
+            output: '../ios/MyApp/Generated/APIClient.swift',
+            namespace: 'API',
+        }),
+    ],
+});
+```
+
 ```sh
-kizuna-swift generate --config kizuna.config.ts --output ios/MyApp/Generated/APIClient.swift --namespace-name API
+kizuna generate
 ```
 
 ## Documentation

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_generator = require("./generator-v_aUFbbV.cjs");
+const require_generator = require("./generator-Bk6JRrTJ.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_util = require("node:util");

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as generateSwiftClient } from "./generator-D2AtmA6u.mjs";
+import { t as generateSwiftClient } from "./generator-2GeebFHv.mjs";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { parseArgs } from "node:util";

package/dist/{generator-D2AtmA6u.mjs → generator-2GeebFHv.mjs}

@@ -1,4 +1,4 @@
-import { createGenerator, isBinarySchema, isDiscriminatedUnionSchema, isFileSchema, isHintPrefix, isIntegerSchema, isJsonMediaType, isNamedStream, isObjectSchema, isStreamResponse, isSuccessStatus, isVoidSchema, localTypeName, mergeHeaderFields, parsePath, readDef, readDefType, readDeprecation, readDiscriminatedUnion, readDiscriminatorStringLiteral, readMetaDescription, readMetaId, readObjectShape, resolveResponseBody, resolveResponseContentType, resolveResponseHeaders, routeStreams, sanitizeFieldName, sanitizeIdentifier, shortTypeName, soleStreamResponse, statusToCamelCase, streamMode, toCamelCase, toPascalCase, unwrapOptionalWrappers } from "kizunajs/generator";
+import { isBinarySchema, isDiscriminatedUnionSchema, isFileSchema, isHintPrefix, isIntegerSchema, isJsonMediaType, isNamedStream, isObjectSchema, isStreamResponse, isSuccessStatus, isVoidSchema, localTypeName, mergeHeaderFields, parsePath, readDef, readDefType, readDeprecation, readDiscriminatedUnion, readDiscriminatorStringLiteral, readMetaBrand, readMetaDescription, readMetaId, readObjectShape, resolveResponseBody, resolveResponseContentType, resolveResponseHeaders, routeStreams, sanitizeFieldName, sanitizeIdentifier, shortTypeName, soleStreamResponse, statusToCamelCase, streamMode, toCamelCase, toPascalCase, unwrapOptionalWrappers, walkApi } from "kizunajs/generator";
 //#region src/emit.ts
 var SwiftWriter = class {
 	lines = [];
@@ -45,6 +45,7 @@ var TypeRegistry = class {
 	warningSet = /* @__PURE__ */ new Set();
 	explicitIds = /* @__PURE__ */ new Set();
 	unionVariantOwners = /* @__PURE__ */ new Map();
+	brands = /* @__PURE__ */ new Map();
 	usesAnyCodable = false;
 	constructor(camelCaseProperties = false, unknownEnumCase = false) {
 		this.camelCaseProperties = camelCaseProperties;
@@ -82,6 +83,15 @@ var TypeRegistry = class {
 	unionVariantOwner(payloadName) {
 		return this.unionVariantOwners.get(payloadName);
 	}
+	addBrand(brand) {
+		const existing = this.brands.get(brand.name);
+		if (existing !== void 0 && existing.rawType !== brand.rawType) throw new Error(`@kizunajs/swift: brand ${stringify(brand.name)} wraps both ${existing.rawType} and ${brand.rawType}. Give each its own name.`);
+		if (this.types.has(brand.name)) throw new Error(`@kizunajs/swift: brand ${stringify(brand.name)} has the same name as a model. Give each its own name.`);
+		this.brands.set(brand.name, brand);
+	}
+	allBrands() {
+		return Array.from(this.brands.values());
+	}
 	warnAnyCodable(hint, reason) {
 		this.usesAnyCodable = true;
 		this.warningSet.add(`${hint}: ${reason}`);
@@ -100,8 +110,7 @@ const propertyName = (key, camelCase) => {
 	if (!camel) return "field";
 	return /^[0-9]/.test(camel) ? `_${camel}` : camel;
 };
-const objectFields = (schema, registry, hint) => {
-	const shape = readObjectShape(schema) ?? {};
+const objectFields = (schema, registry, hint, shape = readObjectShape(schema) ?? {}) => {
 	const fields = [];
 	const seen = /* @__PURE__ */ new Map();
 	for (const [key, value] of Object.entries(shape)) {
@@ -116,6 +125,7 @@ const objectFields = (schema, registry, hint) => {
 			wireName: key,
 			type: result.expression,
 			optional: result.optional,
+			requiredNullable: result.requiredNullable,
 			description: readMetaDescription(value),
 			isFile: result.isFile,
 			deprecated: deprecation !== void 0,
@@ -125,7 +135,29 @@ const objectFields = (schema, registry, hint) => {
 	return fields;
 };
 const stringify = (value) => JSON.stringify(value);
+const BRANDABLE_TYPES = new Set([
+	"String",
+	"Int",
+	"Int64",
+	"Double",
+	"Bool",
+	"Date"
+]);
 const mapType = (schema, registry, hint) => {
+	const result = mapUnbrandedType(schema, registry, hint);
+	const brand = readMetaBrand(schema);
+	if (brand === void 0 || !BRANDABLE_TYPES.has(result.expression)) return result;
+	const name = sanitizeIdentifier(brand);
+	registry.addBrand({
+		name,
+		rawType: result.expression
+	});
+	return {
+		expression: name,
+		optional: false
+	};
+};
+const mapUnbrandedType = (schema, registry, hint) => {
 	if (isFileSchema(schema)) return {
 		expression: "MultipartFile",
 		optional: false,
@@ -199,12 +231,13 @@ const mapType = (schema, registry, hint) => {
 			optional: false
 		};
 	}
-	const { inner, optional } = unwrapOptionalWrappers(schema);
-	if (optional) {
+	const { inner, optional, nullable } = unwrapOptionalWrappers(schema);
+	if (optional || nullable) {
 		const innerResult = mapType(inner, registry, hint);
 		return {
 			expression: innerResult.expression.endsWith("?") ? innerResult.expression : `${innerResult.expression}?`,
 			optional: true,
+			requiredNullable: nullable && !optional,
 			isFile: innerResult.isFile
 		};
 	}
@@ -253,8 +286,9 @@ const mapType = (schema, registry, hint) => {
 					optional: false
 				};
 			}
+			const elementType = mapType(element, registry, `${hint}Item`).expression.replace(/\?$/, "");
 			return {
-				expression: `[${mapType(element, registry, `${hint}Item`).expression.replace(/\?$/, "")}]`,
+				expression: `[${unwrapOptionalWrappers(element).nullable ? `${elementType}?` : elementType}]`,
 				optional: false
 			};
 		}
@@ -388,6 +422,7 @@ const sanitizeCaseName = (literal) => {
 const collectObjectFields = (schema, registry, hint) => {
 	return objectFields(schema, registry, hint);
 };
+const hasDefault = (field) => field.optional && field.requiredNullable !== true;
 const objectFieldCount = (schema) => {
 	return Object.keys(readObjectShape(schema) ?? {}).length;
 };
@@ -556,7 +591,7 @@ const buildRouteMethod = (routeKey, route, registry, deprecated, deprecationMess
 		stream
 	};
 };
-const swiftGenerator = createGenerator((options, _api) => {
+const swiftRoutesWalk = (options) => {
 	const flatMethods = [];
 	const groupMap = /* @__PURE__ */ new Map();
 	return {
@@ -588,7 +623,7 @@ const swiftGenerator = createGenerator((options, _api) => {
 			};
 		}
 	};
-});
+};
 const SWIFT_KEYWORDS = new Set([
 	"associatedtype",
 	"class",
@@ -664,6 +699,10 @@ const sanitizeEnumCaseName = (value) => {
 	if (!camel) return "_";
 	return /^[0-9]/.test(camel) ? `_${camel}` : camel;
 };
+const defaultArgument = (field) => {
+	if (!hasDefault(field)) return "";
+	return " = nil";
+};
 const optionalize = (type, optional) => {
 	if (!optional) return type;
 	return type.endsWith("?") ? type : `${type}?`;
@@ -678,7 +717,7 @@ const emitNamedFactory = (writer, factoryName, fields, buildExpression) => {
 	}
 	const params = fields.map((field) => {
 		const typeExpression = optionalize(field.type, field.optional);
-		const defaultPart = field.optional ? " = nil" : "";
+		const defaultPart = defaultArgument(field);
 		return `${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
 	});
 	const args = fields.map((field) => `${field.name}: ${escapeKeyword(field.name)}`).join(", ");
@@ -701,7 +740,7 @@ const emitMemberwiseInit = (writer, fields, assignmentTarget = (field) => escape
 	}
 	const params = fields.map((field) => {
 		const typeExpression = optionalize(field.type, field.optional);
-		const defaultPart = field.optional ? " = nil" : "";
+		const defaultPart = defaultArgument(field);
 		return `${escapeKeyword(field.name)}: ${typeExpression}${defaultPart}`;
 	});
 	if (params.length === 1) {
@@ -835,7 +874,9 @@ const emitStruct = (writer, type, context, ownedTypeMap, ownedTypeLookup, regist
 		...field,
 		type: resolveOwnedType(field.type)
 	}));
-	const needsCodingKeys = !hasFile && type.fields.some((field) => field.name !== field.wireName || SWIFT_KEYWORDS.has(field.name) || field.deprecated === true);
+	const needsEncode = !hasFile && type.fields.some((field) => field.requiredNullable === true);
+	const needsCodingKeys = needsEncode || !hasFile && type.fields.some((field) => field.name !== field.wireName || SWIFT_KEYWORDS.has(field.name) || field.deprecated === true);
+	const storageName = (field) => field.deprecated ? deprecatedStorageName(field, type.fields) : escapeKeyword(field.name);
 	writer.block(`public struct ${type.name}: ${conformances}`, () => {
 		emitOwnedTypes(writer, lookupName, context, ownedTypeMap, ownedTypeLookup);
 		for (const field of type.fields) {
@@ -858,8 +899,43 @@ const emitStruct = (writer, type, context, ownedTypeMap, ownedTypeLookup, regist
 				else writer.line(`case ${escapeKeyword(field.name)} = ${stringLiteral(field.wireName)}`);
 			});
 		}
+		if (needsEncode) {
+			writer.blank();
+			writer.block("public func encode(to encoder: Encoder) throws", () => {
+				writer.line("var container = encoder.container(keyedBy: CodingKeys.self)");
+				for (const field of type.fields) {
+					const encodeCall = field.optional && field.requiredNullable !== true ? "encodeIfPresent" : "encode";
+					writer.line(`try container.${encodeCall}(${storageName(field)}, forKey: .${storageName(field)})`);
+				}
+			});
+		}
+		writer.blank();
+		emitMemberwiseInit(writer, adjustedFields, storageName);
+	});
+};
+/**
+* A brand as a struct around its value, encoded as the bare value.
+*/
+const emitBrand = (writer, brand) => {
+	writer.block(`public struct ${brand.name}: RawRepresentable, Codable, Hashable, Sendable`, () => {
+		writer.line(`public let rawValue: ${brand.rawType}`);
+		writer.blank();
+		writer.block(`public init(rawValue: ${brand.rawType})`, () => {
+			writer.line("self.rawValue = rawValue");
+		});
+		writer.blank();
+		writer.block(`public init(_ rawValue: ${brand.rawType})`, () => {
+			writer.line("self.rawValue = rawValue");
+		});
+		writer.blank();
+		writer.block("public init(from decoder: Decoder) throws", () => {
+			writer.line(`rawValue = try decoder.singleValueContainer().decode(${brand.rawType}.self)`);
+		});
 		writer.blank();
-		emitMemberwiseInit(writer, adjustedFields, (field) => field.deprecated ? deprecatedStorageName(field, type.fields) : escapeKeyword(field.name));
+		writer.block("public func encode(to encoder: Encoder) throws", () => {
+			writer.line("var container = encoder.singleValueContainer()");
+			writer.line("try container.encode(rawValue)");
+		});
 	});
 };
 const emitDiscriminatedEnum = (writer, type, context, registryName, ownedTypeMap, ownedTypeLookup) => {
@@ -872,7 +948,7 @@ const emitDiscriminatedEnum = (writer, type, context, registryName, ownedTypeMap
 			if (!payloadStruct) continue;
 			const isDiscriminator = (field) => field.wireName === type.discriminator || field.name === type.discriminator;
 			const factoryParams = payloadStruct.fields.filter((field) => !isDiscriminator(field)).map((field) => {
-				const defaultPart = field.optional ? " = nil" : "";
+				const defaultPart = defaultArgument(field);
 				const fieldType = (ownedTypeMap && relativeOwnedPath(field.type, ownedTypeMap, lookupName)) ?? resolveType(field.type, void 0, context);
 				return `${escapeKeyword(field.name)}: ${optionalize(fieldType, field.optional)}${defaultPart}`;
 			}).join(", ");
@@ -955,13 +1031,33 @@ const SWIFT_PRIMITIVE_TYPES = new Set([
 	"Void",
 	"Foundation.Data"
 ]);
+/**
+* Where a dictionary's key ends and its value begins, or -1 for an array.
+*/
+const dictionarySeparator = (inner) => {
+	let depth = 0;
+	for (let index = 0; index < inner.length; index += 1) {
+		const character = inner[index];
+		if (character === "[") depth += 1;
+		else if (character === "]") depth -= 1;
+		else if (character === ":" && depth === 0) return index;
+	}
+	return -1;
+};
 const resolveType = (typeName, currentOperation, context, scope = "actor") => {
 	const { operationTypeMap, namespaceName, clientName, fileLevelTypeNames } = context;
 	const optional = typeName.endsWith("?");
 	const base = optional ? typeName.slice(0, -1) : typeName;
 	if (SWIFT_PRIMITIVE_TYPES.has(base)) return typeName;
 	if (base.startsWith("[") && base.endsWith("]")) {
-		const resolved = resolveType(base.slice(1, -1), currentOperation, context, scope);
+		const inner = base.slice(1, -1);
+		const separator = dictionarySeparator(inner);
+		if (separator !== -1) {
+			const key = resolveType(inner.slice(0, separator).trim(), currentOperation, context, scope);
+			const value = resolveType(inner.slice(separator + 1).trim(), currentOperation, context, scope);
+			return optional ? `[${key}: ${value}]?` : `[${key}: ${value}]`;
+		}
+		const resolved = resolveType(inner, currentOperation, context, scope);
 		return optional ? `[${resolved}]?` : `[${resolved}]`;
 	}
 	if (base === "MultipartFile" || base === "ValidationError" || base === "ValidationIssue") {
@@ -1038,6 +1134,8 @@ const emitToolTracking = (writer, method) => {
 		writer.line("/// How far along the call is.");
 		writer.block("public enum State: Sendable, Equatable", () => {
 			writer.line("case running");
+			writer.line("/// The call waits for the person to approve it.");
+			writer.line("case needsApproval");
 			writer.line("case done");
 			writer.line("case failed");
 		});
@@ -1070,6 +1168,9 @@ const emitToolTracking = (writer, method) => {
 				writer.line("case .tool_call(let payload):");
 				writer.line("    var tracked = at(payload.id, payload.name)");
 				writer.line("    tracked.call = payload");
+				writer.line("    if payload.needsApproval == true, tracked.state == .running {");
+				writer.line("        tracked.state = .needsApproval");
+				writer.line("    }");
 				writer.line("    calls[payload.id] = tracked");
 			}
 			if (names.has("tool_result")) {
@@ -1231,7 +1332,7 @@ const closure = (writer, opener, body) => {
 	writer.indent(body);
 	writer.line("}");
 };
-const emitKizunaStreaming = (writer) => {
+const emitKizunaStreaming = (writer, clientName) => {
 	writer.blank();
 	writer.block("struct ServerSentEvent: Sendable", () => {
 		writer.line("let event: String?");
@@ -1240,21 +1341,39 @@ const emitKizunaStreaming = (writer) => {
 		writer.line("let retry: Int?");
 	});
 	writer.blank();
-	writer.block("static func open<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, failure: Failure.Type) async throws(Failure) -> (URLSession.AsyncBytes, Int, HTTPURLResponse)", () => {
+	writer.block(`static func open<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, retry: ${clientName}.RetryPolicy?, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?, failure: Failure.Type) async throws(Failure) -> (URLSession.AsyncBytes, Int, HTTPURLResponse)`, () => {
 		writer.line("if let requestMiddleware {");
 		writer.line("    do { try await requestMiddleware(&request) }");
 		writer.line("    catch is CancellationError { throw Failure.cancelled }");
 		writer.line("    catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
 		writer.line("    catch { throw Failure.requestFailed(error) }");
 		writer.line("}");
-		writer.line("let bytes: URLSession.AsyncBytes");
-		writer.line("let response: URLResponse");
-		writer.line("do { (bytes, response) = try await session.bytes(for: request) }");
-		writer.line("catch is CancellationError { throw Failure.cancelled }");
-		writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
-		writer.line("catch { throw Failure.requestFailed(error) }");
-		writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
-		writer.line("return (bytes, httpResponse.statusCode, httpResponse)");
+		writer.line("let policy = retryPolicy(for: request, retry)");
+		writer.line("var attempt = 1");
+		writer.block("while true", () => {
+			writer.line("let bytes: URLSession.AsyncBytes");
+			writer.line("let response: URLResponse");
+			writer.line("do { (bytes, response) = try await session.bytes(for: request) }");
+			writer.line("catch is CancellationError { throw Failure.cancelled }");
+			writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+			writer.line("catch {");
+			writer.line("    if let policy, let delay = retryDelay(policy, attempt: attempt, response: nil) {");
+			writer.line("        try await pause(delay, failure: Failure.self)");
+			writer.line("        attempt += 1");
+			writer.line("        continue");
+			writer.line("    }");
+			writer.line("    throw Failure.requestFailed(error)");
+			writer.line("}");
+			writer.line("if let responseMiddleware { await responseMiddleware(request, Foundation.Data(), response) }");
+			writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
+			writer.line("if let policy, let delay = retryDelay(policy, attempt: attempt, response: httpResponse) {");
+			writer.line("    bytes.task.cancel()");
+			writer.line("    try await pause(delay, failure: Failure.self)");
+			writer.line("    attempt += 1");
+			writer.line("    continue");
+			writer.line("}");
+			writer.line("return (bytes, httpResponse.statusCode, httpResponse)");
+		});
 	});
 	writer.blank();
 	writer.block("static func collect<Failure: KizunaFailure>(_ bytes: URLSession.AsyncBytes, failure: Failure.Type) async throws(Failure) -> Foundation.Data", () => {
@@ -1458,22 +1577,68 @@ const emitKizunaNamespace = (writer, options) => {
 			writer.line("catch { throw Failure.requestFailed(error) }");
 		});
 		writer.blank();
-		writer.block("static func send<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?, failure: Failure.Type) async throws(Failure) -> (Foundation.Data, Int, HTTPURLResponse)", () => {
+		writer.block(`static func send<Failure: KizunaFailure>(_ request: inout URLRequest, session: URLSession, retry: ${options.clientName}.RetryPolicy?, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?, failure: Failure.Type) async throws(Failure) -> (Foundation.Data, Int, HTTPURLResponse)`, () => {
 			writer.line("if let requestMiddleware {");
 			writer.line("    do { try await requestMiddleware(&request) }");
 			writer.line("    catch is CancellationError { throw Failure.cancelled }");
 			writer.line("    catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
 			writer.line("    catch { throw Failure.requestFailed(error) }");
 			writer.line("}");
-			writer.line("let data: Foundation.Data");
-			writer.line("let response: URLResponse");
-			writer.line("do { (data, response) = try await session.data(for: request) }");
-			writer.line("catch is CancellationError { throw Failure.cancelled }");
-			writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
-			writer.line("catch { throw Failure.requestFailed(error) }");
-			writer.line("if let responseMiddleware { await responseMiddleware(request, data, response) }");
-			writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
-			writer.line("return (data, httpResponse.statusCode, httpResponse)");
+			writer.line("let policy = retryPolicy(for: request, retry)");
+			writer.line("var attempt = 1");
+			writer.block("while true", () => {
+				writer.line("let data: Foundation.Data");
+				writer.line("let response: URLResponse");
+				writer.line("do { (data, response) = try await session.data(for: request) }");
+				writer.line("catch is CancellationError { throw Failure.cancelled }");
+				writer.line("catch let error as URLError where error.code == .cancelled { throw Failure.cancelled }");
+				writer.line("catch {");
+				writer.line("    if let policy, let delay = retryDelay(policy, attempt: attempt, response: nil) {");
+				writer.line("        try await pause(delay, failure: Failure.self)");
+				writer.line("        attempt += 1");
+				writer.line("        continue");
+				writer.line("    }");
+				writer.line("    throw Failure.requestFailed(error)");
+				writer.line("}");
+				writer.line("if let responseMiddleware { await responseMiddleware(request, data, response) }");
+				writer.line("guard let httpResponse = response as? HTTPURLResponse else { throw Failure.invalidResponse }");
+				writer.line("if let policy, let delay = retryDelay(policy, attempt: attempt, response: httpResponse) {");
+				writer.line("    try await pause(delay, failure: Failure.self)");
+				writer.line("    attempt += 1");
+				writer.line("    continue");
+				writer.line("}");
+				writer.line("return (data, httpResponse.statusCode, httpResponse)");
+			});
+		});
+		writer.blank();
+		writer.block(`static func retryPolicy(for request: URLRequest, _ retry: ${options.clientName}.RetryPolicy?) -> ${options.clientName}.RetryPolicy?`, () => {
+			writer.line("let idempotent = [\"GET\", \"HEAD\", \"OPTIONS\", \"PUT\", \"DELETE\"].contains(request.httpMethod ?? \"GET\")");
+			writer.line("return idempotent && request.httpBodyStream == nil ? retry : nil");
+		});
+		writer.blank();
+		writer.block(`static func retryDelay(_ policy: ${options.clientName}.RetryPolicy, attempt: Int, response: HTTPURLResponse?) -> TimeInterval?`, () => {
+			writer.line("guard attempt < policy.maximumAttempts else { return nil }");
+			writer.line("let backoff = Double.random(in: 0...min(policy.maximumDelay, policy.initialDelay * pow(2, Double(attempt - 1))))");
+			writer.line("guard let response else { return backoff }");
+			writer.line("guard [429, 503].contains(response.statusCode) else { return nil }");
+			writer.line("guard let asked = retryAfter(response.value(forHTTPHeaderField: \"Retry-After\")) else { return backoff }");
+			writer.line("return asked <= policy.maximumDelay ? asked : nil");
+		});
+		writer.blank();
+		writer.block("static func retryAfter(_ header: String?) -> TimeInterval?", () => {
+			writer.line("guard let value = header?.trimmingCharacters(in: .whitespaces) else { return nil }");
+			writer.line("if let seconds = Int(value), seconds >= 0 { return TimeInterval(seconds) }");
+			writer.line("let formatter = DateFormatter()");
+			writer.line("formatter.locale = Locale(identifier: \"en_US_POSIX\")");
+			writer.line("formatter.timeZone = TimeZone(identifier: \"GMT\")");
+			writer.line("formatter.dateFormat = \"EEE, dd MMM yyyy HH:mm:ss zzz\"");
+			writer.line("guard let date = formatter.date(from: value) else { return nil }");
+			writer.line("return max(0, date.timeIntervalSinceNow)");
+		});
+		writer.blank();
+		writer.block("static func pause<Failure: KizunaFailure>(_ seconds: TimeInterval, failure: Failure.Type) async throws(Failure)", () => {
+			writer.line("do { try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000)) }");
+			writer.line("catch { throw Failure.cancelled }");
 		});
 		writer.blank();
 		writer.block("static func decode<Value: Decodable, Failure: KizunaDecodableFailure>(_ type: Value.Type, from data: Foundation.Data, using decoder: JSONDecoder, statusCode: Int, failure: Failure.Type) throws(Failure) -> Value", () => {
@@ -1489,7 +1654,7 @@ const emitKizunaNamespace = (writer, options) => {
 				writer.line("return Failure.decoding(DecodingError.dataCorrupted(.init(codingPath: [], debugDescription: \"No matching type for status \\(statusCode)\")), statusCode: statusCode, data: data)");
 			});
 		}
-		if (options.streaming) emitKizunaStreaming(writer);
+		if (options.streaming) emitKizunaStreaming(writer, options.clientName);
 		if (options.multipart) {
 			writer.blank();
 			writer.block("struct MultipartBuilder", () => {
@@ -1570,13 +1735,13 @@ const methodGroups = (method, context) => {
 		varName: "query",
 		type: groupTypeRef(operationName, "Query", context),
 		factory: "query",
-		required: method.query.some((field) => !field.optional)
+		required: method.query.some((field) => !hasDefault(field))
 	});
 	if (method.headers.length > 0) groups.push({
 		varName: "headers",
 		type: groupTypeRef(operationName, "Headers", context),
 		factory: "headers",
-		required: method.headers.some((field) => !field.optional)
+		required: method.headers.some((field) => !hasDefault(field))
 	});
 	return [...groups.filter((group) => group.required), ...groups.filter((group) => !group.required)];
 };
@@ -1632,7 +1797,7 @@ const emitMethodBody = (writer, method, context, receiver = "") => {
 		emitStreamMethodTail(writer, method, context, receiver, responseBinding);
 		return;
 	}
-	writer.line(`let (data, statusCode, ${responseBinding}) = try await Kizuna.send(&request, session: ${receiver}session, requestMiddleware: ${receiver}requestMiddleware, responseMiddleware: ${receiver}responseMiddleware, failure: ${failure}.self)`);
+	writer.line(`let (data, statusCode, ${responseBinding}) = try await Kizuna.send(&request, session: ${receiver}session, retry: ${receiver}retry, requestMiddleware: ${receiver}requestMiddleware, responseMiddleware: ${receiver}responseMiddleware, failure: ${failure}.self)`);
 	writer.line("switch statusCode {");
 	for (const successResponse of method.successResponses) {
 		writer.line(`case ${successResponse.status}:`);
@@ -1707,7 +1872,7 @@ const emitStreamMethodTail = (writer, method, context, receiver, responseBinding
 	const qualifiedResult = `${context.clientName}.${method.operationName}.${method.resultWrapperName}`;
 	const hasHeaders = method.resultHeaderFields.length > 0;
 	const collect = `let data = try await Kizuna.collect(bytes, failure: ${failure}.self)`;
-	writer.line(`let (bytes, statusCode, ${responseBinding}) = try await Kizuna.open(&request, session: ${receiver}session, requestMiddleware: ${receiver}requestMiddleware, failure: ${failure}.self)`);
+	writer.line(`let (bytes, statusCode, ${responseBinding}) = try await Kizuna.open(&request, session: ${receiver}session, retry: ${receiver}retry, requestMiddleware: ${receiver}requestMiddleware, responseMiddleware: ${receiver}responseMiddleware, failure: ${failure}.self)`);
 	writer.line("switch statusCode {");
 	writer.line(`case ${stream.status}:`);
 	writer.indent(() => {
@@ -1792,9 +1957,15 @@ const emitBodyEncoding = (writer, method, context, receiver = "") => {
 		writer.line("var multipart = Kizuna.MultipartBuilder()");
 		for (const field of body.multipartFields) {
 			const flattenedField = body.flattened.find((candidate) => candidate.name === field.name);
-			const accessor = `body.${escapeKeyword(field.name)}`;
-			if (field.isFile || flattenedField?.isFile === true) writer.line(`multipart.appendFile(name: ${stringLiteral(field.wireName)}, file: ${accessor})`);
-			else writer.line(`multipart.appendField(name: ${stringLiteral(field.wireName)}, value: String(describing: ${accessor}))`);
+			const isFile = field.isFile || flattenedField?.isFile === true;
+			const append = (accessor) => {
+				if (isFile) writer.line(`multipart.appendFile(name: ${stringLiteral(field.wireName)}, file: ${accessor})`);
+				else writer.line(`multipart.appendField(name: ${stringLiteral(field.wireName)}, value: String(describing: ${accessor}))`);
+			};
+			if (flattenedField?.optional === true) writer.block(`if let value = body.${escapeKeyword(field.name)}`, () => {
+				append("value");
+			});
+			else append(`body.${escapeKeyword(field.name)}`);
 		}
 		writer.line("request.httpBody = multipart.finalize()");
 		writer.line("request.setValue(multipart.contentType, forHTTPHeaderField: \"Content-Type\")");
@@ -1813,7 +1984,7 @@ const emitClient = (writer, config, partition, context, typesByOperation) => {
 	const allMethods = [...flatMethods, ...groups.flatMap((group) => group.methods)];
 	const usesMultipart = allMethods.some((method) => method.body?.kind === "multipart");
 	const contextFields = context.requestContextFields;
-	const contextRequired = contextFields.some((field) => !field.optional);
+	const contextRequired = contextFields.some((field) => !hasDefault(field));
 	writer.blank();
 	writer.block(`public final class ${clientName}: Sendable`, () => {
 		if (contextFields.length > 0) {
@@ -1822,7 +1993,7 @@ const emitClient = (writer, config, partition, context, typesByOperation) => {
 			writer.block("public struct RequestContext: Sendable, Equatable", () => {
 				for (const field of contextFields) writer.line(`public var ${escapeKeyword(field.name)}: ${field.type}`);
 				writer.blank();
-				const initParams = contextFields.map((field) => `${escapeKeyword(field.name)}: ${field.type}${field.optional ? " = nil" : ""}`).join(", ");
+				const initParams = contextFields.map((field) => `${escapeKeyword(field.name)}: ${field.type}${defaultArgument(field)}`).join(", ");
 				writer.block(`public init(${initParams})`, () => {
 					for (const field of contextFields) writer.line(`self.${escapeKeyword(field.name)} = ${escapeKeyword(field.name)}`);
 				});
@@ -1835,6 +2006,22 @@ const emitClient = (writer, config, partition, context, typesByOperation) => {
 				});
 			});
 		}
+		writer.blank();
+		writer.docComment("Retries a GET, HEAD, OPTIONS, PUT or DELETE that failed on the network or was answered 429 or 503, waiting what Retry-After asks or backing off.");
+		writer.block("public struct RetryPolicy: Sendable", () => {
+			writer.docComment("Attempts in all, the first included.");
+			writer.line("public var maximumAttempts: Int");
+			writer.docComment("Seconds the first backoff waits at most.");
+			writer.line("public var initialDelay: TimeInterval");
+			writer.docComment("Seconds any wait may take.");
+			writer.line("public var maximumDelay: TimeInterval");
+			writer.blank();
+			writer.block("public init(maximumAttempts: Int = 3, initialDelay: TimeInterval = 0.5, maximumDelay: TimeInterval = 30)", () => {
+				writer.line("self.maximumAttempts = maximumAttempts");
+				writer.line("self.initialDelay = initialDelay");
+				writer.line("self.maximumDelay = maximumDelay");
+			});
+		});
 		if (usesMultipart) {
 			writer.blank();
 			writer.block("public struct MultipartFile: Sendable, Equatable", () => {
@@ -1932,14 +2119,16 @@ const emitClient = (writer, config, partition, context, typesByOperation) => {
 		if (contextFields.length > 0) writer.line("let requestContextHeaders: [String: String]");
 		writer.line("public let requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)?");
 		writer.line("public let responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)?");
+		writer.line("public let retry: RetryPolicy?");
 		writer.line("let encoder: JSONEncoder");
 		writer.line("let decoder: JSONDecoder");
 		writer.blank();
 		const contextInitParam = contextFields.length > 0 ? `, requestContext: RequestContext${contextRequired ? "" : " = RequestContext()"}` : "";
-		writer.block(`public init(baseURL: URL, session: URLSession = .shared, timeout: TimeInterval = 30${contextInitParam}, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)? = nil, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)? = nil)`, () => {
+		writer.block(`public init(baseURL: URL, session: URLSession = .shared, timeout: TimeInterval = 30, retry: RetryPolicy? = nil${contextInitParam}, requestMiddleware: (@Sendable (inout URLRequest) async throws -> Void)? = nil, responseMiddleware: (@Sendable (URLRequest, Foundation.Data, URLResponse) async -> Void)? = nil)`, () => {
 			writer.line("self.baseURL = baseURL");
 			writer.line("self.session = session");
 			writer.line("self.timeout = timeout");
+			writer.line("self.retry = retry");
 			if (contextFields.length > 0) writer.line("self.requestContextHeaders = requestContext.headerFields");
 			writer.line("self.requestMiddleware = requestMiddleware");
 			writer.line("self.responseMiddleware = responseMiddleware");
@@ -1971,18 +2160,8 @@ const emitClient = (writer, config, partition, context, typesByOperation) => {
 		}
 	});
 };
-/**
-* Generate a Swift API client from a kizuna config.
-*
-*   - `namespaceName`: the actor class. Defaults to `APIClient`.
-*/
-const generateSwiftClient = (api, options) => {
-	const { namespaceName, camelCaseProperties = false, unknownEnumCase = false } = options;
-	const registry = new TypeRegistry(camelCaseProperties, unknownEnumCase);
-	const partition = swiftGenerator(api, {
-		namespaceName,
-		registry
-	});
+const renderSwiftClient = (api, partition, registry, options) => {
+	const { namespaceName } = options;
 	const allMethods = [...partition.flatMethods, ...partition.groups.flatMap((group) => group.methods)];
 	const operationTypeMap = buildOperationTypeMap(allMethods, registry);
 	const clientName = `${namespaceName}Client`;
@@ -2043,6 +2222,10 @@ const generateSwiftClient = (api, options) => {
 	};
 	writer.block(`public enum ${namespaceName}`, () => {
 		emitTypes(writer, topLevelSharedTypes, context, ownedTypeMap, ownedTypeLookup);
+		for (const brand of registry.allBrands()) {
+			writer.blank();
+			emitBrand(writer, brand);
+		}
 	});
 	emitClient(writer, {
 		clientName,
@@ -2059,5 +2242,25 @@ const generateSwiftClient = (api, options) => {
 	for (const warning of registry.warnings()) process.stderr.write(`[kizuna/swift] AnyCodable fallback at ${warning}\n`);
 	return writer.toString();
 };
+/**
+* The Swift client's walk: the routes into a partition, then the file.
+*/
+const swiftClientWalk = (api, options) => {
+	const registry = new TypeRegistry(options.camelCaseProperties ?? false, options.unknownEnumCase ?? false);
+	const routes = swiftRoutesWalk({
+		namespaceName: options.namespaceName,
+		registry
+	});
+	return {
+		processRoute: routes.processRoute,
+		finalize: () => renderSwiftClient(api, routes.finalize(), registry, options)
+	};
+};
+/**
+* Generate a Swift API client from a kizuna config.
+*
+*   - `namespaceName`: the actor class. Defaults to `APIClient`.
+*/
+const generateSwiftClient = (api, options) => walkApi(api, swiftClientWalk(api, options), { skipHidden: true });
 //#endregion
-export { generateSwiftClient as t };
+export { swiftClientWalk as n, generateSwiftClient as t };