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

package/dist/{generator-v_aUFbbV.cjs → generator-D8fdPAdY.cjs}

@@ -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 = (0, kizunajs_generator.readObjectShape)(schema) ?? {};
+const objectFields = (schema, registry, hint, shape = (0, kizunajs_generator.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: (0, kizunajs_generator.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 = (0, kizunajs_generator.readMetaBrand)(schema);
+	if (brand === void 0 || !BRANDABLE_TYPES.has(result.expression)) return result;
+	const name = (0, kizunajs_generator.sanitizeIdentifier)(brand);
+	registry.addBrand({
+		name,
+		rawType: result.expression
+	});
+	return {
+		expression: name,
+		optional: false
+	};
+};
+const mapUnbrandedType = (schema, registry, hint) => {
 	if ((0, kizunajs_generator.isFileSchema)(schema)) return {
 		expression: "MultipartFile",
 		optional: false,
@@ -199,12 +231,13 @@ const mapType = (schema, registry, hint) => {
 			optional: false
 		};
 	}
-	const { inner, optional } = (0, kizunajs_generator.unwrapOptionalWrappers)(schema);
-	if (optional) {
+	const { inner, optional, nullable } = (0, kizunajs_generator.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: `[${(0, kizunajs_generator.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((0, kizunajs_generator.readObjectShape)(schema) ?? {}).length;
 };
@@ -556,7 +591,7 @@ const buildRouteMethod = (routeKey, route, registry, deprecated, deprecationMess
 		stream
 	};
 };
-const swiftGenerator = (0, kizunajs_generator.createGenerator)((options, _api) => {
+const swiftRoutesWalk = (options) => {
 	const flatMethods = [];
 	const groupMap = /* @__PURE__ */ new Map();
 	return {
@@ -588,7 +623,7 @@ const swiftGenerator = (0, kizunajs_generator.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,44 @@ 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("struct Reconnection: Sendable", () => {
+		writer.line(`let policy: ${clientName}.ReconnectPolicy`);
+		writer.line("let reopen: @Sendable (String) async throws -> URLSession.AsyncBytes?");
+	});
+	writer.blank();
+	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", () => {
@@ -1314,56 +1438,97 @@ const emitKizunaStreaming = (writer) => {
 		});
 	});
 	writer.blank();
-	writer.block("static func serverSentEvents(_ bytes: URLSession.AsyncBytes) -> AsyncThrowingStream<ServerSentEvent, Swift.Error>", () => {
+	writer.block("static func serverSentEvents(_ first: URLSession.AsyncBytes, reconnect: Reconnection?) -> AsyncThrowingStream<ServerSentEvent, Swift.Error>", () => {
 		closure(writer, "AsyncThrowingStream { continuation in", () => {
 			writer.block("let task = Task", () => {
-				writer.line("var eventType = \"\"");
-				writer.line("var dataLines: [String] = []");
 				writer.line("var lastEventId = \"\"");
-				writer.line("var retry: Int? = nil");
-				writer.block("do", () => {
-					writer.block("for try await line in lines(bytes)", () => {
-						writer.line("if line.isEmpty {");
-						writer.line("    if !dataLines.isEmpty {");
-						writer.line("        continuation.yield(ServerSentEvent(event: eventType.isEmpty ? nil : eventType, data: dataLines.joined(separator: \"\\n\"), id: lastEventId.isEmpty ? nil : lastEventId, retry: retry))");
-						writer.line("        dataLines = []");
-						writer.line("        retry = nil");
-						writer.line("    }");
-						writer.line("    eventType = \"\"");
-						writer.line("    continue");
-						writer.line("}");
-						writer.line("if line.hasPrefix(\":\") { continue }");
-						writer.line("let field: Substring");
-						writer.line("var value: Substring");
-						writer.line("if let separator = line.firstIndex(of: \":\") {");
-						writer.line("    field = line[..<separator]");
-						writer.line("    value = line[line.index(after: separator)...]");
-						writer.line("    if value.hasPrefix(\" \") { value = value.dropFirst() }");
-						writer.line("} else {");
-						writer.line("    field = Substring(line)");
-						writer.line("    value = \"\"");
-						writer.line("}");
-						writer.line("switch field {");
-						writer.line("case \"event\": eventType = String(value)");
-						writer.line("case \"data\": dataLines.append(String(value))");
-						writer.line("case \"id\": if !value.contains(\"\\0\") { lastEventId = String(value) }");
-						writer.line("case \"retry\": if !value.isEmpty, value.allSatisfy(\\.isNumber), let milliseconds = Int(value) { retry = milliseconds }");
-						writer.line("default: break");
+				writer.line("var reconnectionTime = reconnect?.policy.reconnectionTime ?? 3");
+				writer.line("var bytes: URLSession.AsyncBytes? = first");
+				writer.line("var attempts = 0");
+				writer.line("var failure: Swift.Error? = nil");
+				writer.block("while true", () => {
+					writer.block("if let current = bytes", () => {
+						writer.line("var eventType = \"\"");
+						writer.line("var dataLines: [String] = []");
+						writer.line("var pendingId = lastEventId");
+						writer.line("var retry: Int? = nil");
+						writer.line("var firstLine = true");
+						writer.block("do", () => {
+							writer.block("for try await received in lines(current)", () => {
+								writer.line("let line = firstLine && received.hasPrefix(\"\\u{FEFF}\") ? String(received.dropFirst()) : received");
+								writer.line("firstLine = false");
+								writer.line("if line.isEmpty {");
+								writer.line("    lastEventId = pendingId");
+								writer.line("    if !dataLines.isEmpty {");
+								writer.line("        continuation.yield(ServerSentEvent(event: eventType.isEmpty ? nil : eventType, data: dataLines.joined(separator: \"\\n\"), id: lastEventId.isEmpty ? nil : lastEventId, retry: retry))");
+								writer.line("        attempts = 0");
+								writer.line("        failure = nil");
+								writer.line("        dataLines = []");
+								writer.line("        retry = nil");
+								writer.line("    }");
+								writer.line("    eventType = \"\"");
+								writer.line("    continue");
+								writer.line("}");
+								writer.line("if line.hasPrefix(\":\") { continue }");
+								writer.line("let field: Substring");
+								writer.line("var value: Substring");
+								writer.line("if let separator = line.firstIndex(of: \":\") {");
+								writer.line("    field = line[..<separator]");
+								writer.line("    value = line[line.index(after: separator)...]");
+								writer.line("    if value.hasPrefix(\" \") { value = value.dropFirst() }");
+								writer.line("} else {");
+								writer.line("    field = Substring(line)");
+								writer.line("    value = \"\"");
+								writer.line("}");
+								writer.line("switch field {");
+								writer.line("case \"event\": eventType = String(value)");
+								writer.line("case \"data\": dataLines.append(String(value))");
+								writer.line("case \"id\": if !value.contains(\"\\0\") { pendingId = String(value) }");
+								writer.line("case \"retry\": if !value.isEmpty, value.allSatisfy({ $0.isASCII && $0.isNumber }), let milliseconds = Int(value) { retry = milliseconds; reconnectionTime = min(TimeInterval(milliseconds) / 1000, 3600) }");
+								writer.line("default: break");
+								writer.line("}");
+							});
+						});
+						writer.line("catch { failure = error }");
+					});
+					writer.line("guard let reconnect, !Task.isCancelled, attempts < reconnect.policy.maximumAttempts else {");
+					writer.line("    continuation.finish(throwing: failure)");
+					writer.line("    return");
+					writer.line("}");
+					writer.line("attempts += 1");
+					writer.line("let ceiling = min(reconnect.policy.maximumDelay, reconnectionTime * pow(2, Double(attempts - 1)))");
+					writer.line("let delay = max(0, reconnectionTime) + Double.random(in: 0...max(0, ceiling - reconnectionTime))");
+					writer.line("do { try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000)) }");
+					writer.line("catch {");
+					writer.line("    continuation.finish(throwing: failure)");
+					writer.line("    return");
+					writer.line("}");
+					writer.block("do", () => {
+						writer.line("guard let reopened = try await reconnect.reopen(lastEventId) else {");
+						writer.line("    continuation.finish()");
+						writer.line("    return");
 						writer.line("}");
+						writer.line("bytes = reopened");
+					});
+					writer.block("catch let error as URLError", () => {
+						writer.line("failure = error");
+						writer.line("bytes = nil");
+					});
+					writer.block("catch", () => {
+						writer.line("continuation.finish(throwing: error)");
+						writer.line("return");
 					});
-					writer.line("continuation.finish()");
 				});
-				writer.line("catch { continuation.finish(throwing: error) }");
 			});
 			writer.line("continuation.onTermination = { _ in task.cancel() }");
 		});
 	});
 	writer.blank();
-	writer.block("static func events<Event: Sendable>(_ bytes: URLSession.AsyncBytes, using decoder: JSONDecoder, _ decode: @escaping @Sendable (ServerSentEvent, JSONDecoder) throws -> Event?) -> AsyncThrowingStream<Event, Swift.Error>", () => {
+	writer.block("static func events<Event: Sendable>(_ bytes: URLSession.AsyncBytes, using decoder: JSONDecoder, reconnect: Reconnection? = nil, _ decode: @escaping @Sendable (ServerSentEvent, JSONDecoder) throws -> Event?) -> AsyncThrowingStream<Event, Swift.Error>", () => {
 		closure(writer, "AsyncThrowingStream { continuation in", () => {
 			writer.block("let task = Task", () => {
 				writer.block("do", () => {
-					writer.block("for try await event in serverSentEvents(bytes)", () => {
+					writer.block("for try await event in serverSentEvents(bytes, reconnect: reconnect)", () => {
 						writer.line("if let decoded = try decode(event, decoder) { continuation.yield(decoded) }");
 					});
 					writer.line("continuation.finish()");
@@ -1458,22 +1623,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 +1700,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 +1781,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 +1843,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}:`);
@@ -1700,6 +1911,35 @@ const emitErrorCases = (writer, method, context, receiver, prelude) => {
 		}
 	}
 };
+const IDEMPOTENT_METHODS = new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"PUT",
+	"DELETE"
+]);
+/**
+* Writes the closure that reopens an event stream and returns the argument handing it to `Kizuna.events`, or nothing
+* for a method a client may not resend.
+*/
+const emitReopen = (writer, method, receiver, failure, status) => {
+	if (!IDEMPOTENT_METHODS.has(method.method)) return "";
+	closure(writer, `let reopen: @Sendable (String) async throws -> URLSession.AsyncBytes? = { [request, session = ${receiver}session, retry = ${receiver}retry, requestMiddleware = ${receiver}requestMiddleware, responseMiddleware = ${receiver}responseMiddleware] lastEventId in`, () => {
+		writer.line("var again = request");
+		writer.line("if !lastEventId.isEmpty { again.setValue(lastEventId, forHTTPHeaderField: \"Last-Event-ID\") }");
+		writer.line("let reopened: (URLSession.AsyncBytes, Int, HTTPURLResponse)");
+		writer.line(`do { reopened = try await Kizuna.open(&again, session: session, retry: retry, requestMiddleware: requestMiddleware, responseMiddleware: responseMiddleware, failure: ${failure}.self) }`);
+		writer.line(`catch let failure as ${failure} {`);
+		writer.line("    if case .requestFailed(let underlying) = failure { throw underlying }");
+		writer.line("    throw failure");
+		writer.line("}");
+		writer.line("if reopened.1 == 204 { return nil }");
+		writer.line(`guard reopened.1 == ${status} else { throw ${failure}.unexpectedStatus(reopened.1, Foundation.Data()) }`);
+		writer.line(`guard reopened.2.value(forHTTPHeaderField: "Content-Type")?.lowercased().hasPrefix("text/event-stream") == true else { throw ${failure}.invalidResponse }`);
+		writer.line("return reopened.0");
+	});
+	return `, reconnect: ${receiver}reconnect.map { Kizuna.Reconnection(policy: $0, reopen: reopen) }`;
+};
 const emitStreamMethodTail = (writer, method, context, receiver, responseBinding) => {
 	const failure = failureRef(method, context);
 	const stream = method.stream;
@@ -1707,7 +1947,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(() => {
@@ -1715,7 +1955,8 @@ const emitStreamMethodTail = (writer, method, context, receiver, responseBinding
 		else if (stream.mode === "binary") writer.line("let body = Kizuna.chunks(bytes)");
 		else if (stream.events) {
 			const events = stream.events;
-			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder) { event, decoder -> ${streamElementType(method, context, "actor")}? in`, () => {
+			const elementType = streamElementType(method, context, "actor");
+			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder${emitReopen(writer, method, receiver, failure, stream.status)}) { event, decoder -> ${elementType}? in`, () => {
 				writer.line("switch event.event {");
 				for (const event of events) {
 					const payloadType = resolveType(event.type, method.operationName, context);
@@ -1726,7 +1967,7 @@ const emitStreamMethodTail = (writer, method, context, receiver, responseBinding
 			});
 		} else {
 			const elementType = streamElementType(method, context, "actor");
-			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder) { event, decoder -> ${elementType}? in`, () => {
+			closure(writer, `let body = Kizuna.events(bytes, using: ${receiver}decoder${emitReopen(writer, method, receiver, failure, stream.status)}) { event, decoder -> ${elementType}? in`, () => {
 				writer.line(`try decoder.decode(${elementType}.self, from: Foundation.Data(event.data.utf8))`);
 			});
 		}
@@ -1792,9 +2033,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 +2060,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 +2069,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 +2082,38 @@ 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");
+			});
+		});
+		writer.blank();
+		writer.docComment("Reconnects an event stream on a GET, HEAD, OPTIONS, PUT or DELETE when its connection drops, sending the id of the last event as Last-Event-ID.");
+		writer.block("public struct ReconnectPolicy: Sendable", () => {
+			writer.docComment("Reconnections in a row before the stream fails. An event received resets the count.");
+			writer.line("public var maximumAttempts: Int");
+			writer.docComment("Seconds to wait before reconnecting, until the server sends a retry field.");
+			writer.line("public var reconnectionTime: TimeInterval");
+			writer.docComment("Seconds the wait may grow to after reconnections in a row that fail.");
+			writer.line("public var maximumDelay: TimeInterval");
+			writer.blank();
+			writer.block("public init(maximumAttempts: Int = 5, reconnectionTime: TimeInterval = 3, maximumDelay: TimeInterval = 30)", () => {
+				writer.line("self.maximumAttempts = maximumAttempts");
+				writer.line("self.reconnectionTime = reconnectionTime");
+				writer.line("self.maximumDelay = maximumDelay");
+			});
+		});
 		if (usesMultipart) {
 			writer.blank();
 			writer.block("public struct MultipartFile: Sendable, Equatable", () => {
@@ -1932,14 +2211,18 @@ 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("public let reconnect: ReconnectPolicy?");
 		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, reconnect: ReconnectPolicy? = 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");
+			writer.line("self.reconnect = reconnect");
 			if (contextFields.length > 0) writer.line("self.requestContextHeaders = requestContext.headerFields");
 			writer.line("self.requestMiddleware = requestMiddleware");
 			writer.line("self.responseMiddleware = responseMiddleware");
@@ -1971,18 +2254,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 +2316,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,6 +2336,26 @@ 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) => (0, kizunajs_generator.walkApi)(api, swiftClientWalk(api, options), { skipHidden: true });
 //#endregion
 Object.defineProperty(exports, "generateSwiftClient", {
 	enumerable: true,
@@ -2066,3 +2363,9 @@ Object.defineProperty(exports, "generateSwiftClient", {
 		return generateSwiftClient;
 	}
 });
+Object.defineProperty(exports, "swiftClientWalk", {
+	enumerable: true,
+	get: function() {
+		return swiftClientWalk;
+	}
+});