primitive-admin 1.0.53 → 1.0.55

package/dist/src/lib/swift-codegen/schemaToSwift.js

@@ -0,0 +1,644 @@
+/**
+ * JSON-Schema → Swift `Codable` converter for `swift-codegen` (issue #1547,
+ * Phase 1). The Swift counterpart of `workflow-codegen/schemaToTs.ts`.
+ *
+ * Both emitters read the SAME drift-guarded interpretation of the JSON-Schema
+ * subset the workflow platform supports — the vendored `SchemaDescriptor`
+ * (`workflow-codegen/generated-schema-descriptor.ts`, a byte copy of the server
+ * validator). Only the emitted syntax differs, so a generated Swift type can
+ * never promise a shape the runtime validator rejects. See the design and
+ * maintainer decision on issue #1547.
+ *
+ * Where Swift diverges from TypeScript:
+ *
+ *   - **Named types, not anonymous.** TS renders nested object/enum/`oneOf`
+ *     types inline; Swift `Codable` needs a NAMED `struct`/`enum` for each, so
+ *     this emitter declares nested types inside their enclosing type.
+ *   - **Scalars** (Fork 4, maintainer-confirmed): `string`→`String`,
+ *     `number`→`Double`, `integer`→`Int` (ergonomic divergence from TS
+ *     `number`), `boolean`→`Bool`.
+ *   - **Un-descended nodes** (`$ref`, `allOf`, `format`, tuple `items`,
+ *     `patternProperties`, numeric constraints, multi-scalar non-null unions,
+ *     mixed-type enums, open-object extra values) → `JSONValue`, the Swift
+ *     analog of TS `unknown`.
+ *   - **`never`** (an uninhabitable enum after the type gate) → a strict codegen
+ *     error, since the field can never be constructed (Fork 4).
+ *   - **Scalar `enum`, all strings** → a nested `enum … : String, Codable,
+ *     CaseIterable, Sendable`, the same form the Swift model codegen emits.
+ *   - **`oneOf` discriminated union** → an `enum` with associated values plus a
+ *     generated `init(from:)`/`encode(to:)` keyed on the discriminator.
+ *
+ * Codable semantics adopted from the maintainer decision (binding item 4):
+ *
+ *   - Every generated `struct` gets a generated **public memberwise
+ *     initializer** (Swift's synthesized memberwise init is not `public` across
+ *     module boundaries).
+ *   - A **required-nullable** property (required, but its value may be `null`)
+ *     is encoded with an EXPLICIT null (not omitted) so server-side
+ *     required-key validation still sees the key; decode is lenient (a missing
+ *     key decodes to `nil`).
+ *   - An **open object** stores unknown keys in an `extra: [String: JSONValue]`
+ *     catch-all via custom Codable that separates known keys from extras; a key
+ *     that collides with a known property is owned by the known property (the
+ *     extra copy is dropped on encode, and never captured on decode).
+ *   - A `oneOf` branch `struct` CARRIES the discriminator as a single-case
+ *     `String` enum property, so decoding a branch rejects a conflicting
+ *     discriminator value, and encoding re-emits the tag from the branch.
+ *
+ * Errors are named (`SwiftCodegenError`) and carry the source file and schema
+ * path for diagnostics (binding item 6).
+ */
+import { describeSchema, isType, } from "../workflow-codegen/generated-schema-descriptor.js";
+import { schemaRejectsEmptyObject } from "../workflow-codegen/schemaToTs.js";
+import { enumCaseIdentifier, enumCaseNames, enumTypeName, escapeIfReserved, structTypeName, swiftPropertyName, unescapeIdentifier, } from "./swiftNaming.js";
+/** Re-exported so the invoker phases share ONE required-vs-optional decision. */
+export { schemaRejectsEmptyObject };
+/** Conformances every generated struct/enum promises (all satisfied by `JSONValue`). */
+const CONFORMANCES = "Codable, Equatable, Sendable";
+const ACCESS = "public";
+const INDENT_UNIT = "    ";
+/** A named codegen error carrying the source file + schema path (binding 6). */
+export class SwiftCodegenError extends Error {
+    sourceFile;
+    schemaPath;
+    constructor(message, opts) {
+        const where = [opts?.sourceFile, opts?.schemaPath]
+            .filter((s) => s)
+            .join(" ");
+        super(where ? `${message} (at ${where})` : message);
+        this.name = "SwiftCodegenError";
+        this.sourceFile = opts?.sourceFile;
+        this.schemaPath = opts?.schemaPath;
+    }
+}
+const SCALAR_SWIFT = {
+    string: "String",
+    number: "Double",
+    integer: "Int",
+    boolean: "Bool",
+};
+/** A Swift string literal with the escapes Swift needs. */
+function swiftString(value) {
+    const escaped = value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t")
+        .replace(/\0/g, "\\0");
+    return `"${escaped}"`;
+}
+/**
+ * Render a full Swift type declaration for a ROOT schema (e.g. a workflow's
+ * `<Key>Input`/`<Key>Output`), including every nested type it needs. Returns the
+ * Swift source for the type only — the CLI adds the import/banner (Phase 2).
+ */
+export function renderSwiftRootType(rootTypeName, schema, ctx) {
+    const state = {
+        sourceFile: ctx?.sourceFile,
+        path: rootTypeName,
+        fail(message) {
+            throw new SwiftCodegenError(message, {
+                sourceFile: this.sourceFile,
+                schemaPath: this.path,
+            });
+        },
+    };
+    const d = describeSchema(schema);
+    // A qualifying `oneOf` becomes a root enum with associated values.
+    if (d.oneOf) {
+        if (d.oneOf.kind === "invalid") {
+            state.fail(`swift codegen: ${d.oneOf.reason}`);
+        }
+        return renderOneOfEnum(rootTypeName, d.oneOf, 0, state);
+    }
+    // A root scalar `enum` (all strings) becomes a top-level String enum.
+    const rootEnum = renderStringEnumIfApplicable(d, rootTypeName, 0, state);
+    if (rootEnum)
+        return rootEnum;
+    // A root object becomes a struct.
+    if (d.singularType === "object" && d.object) {
+        return renderStruct(rootTypeName, d.object, 0, state);
+    }
+    // Anything else (scalar, array, union, un-descended) is a typealias to the
+    // reference type. Nested type declarations (e.g. an array's element struct)
+    // are emitted before the alias.
+    const ref = renderTypeRef(schema, rootTypeName, 0, state);
+    const alias = `${ACCESS} typealias ${rootTypeName} = ${optionalize(ref)}`;
+    return ref.decls.length > 0 ? `${ref.decls.join("\n\n")}\n\n${alias}` : alias;
+}
+/** Apply `?` to a reference type when the node is nullable. */
+function optionalize(ref) {
+    return ref.nullable ? `${ref.expr}?` : ref.expr;
+}
+/**
+ * Render a schema node as a Swift type reference, accumulating any nested type
+ * declarations. `nameHint` is the base name for a nested named type (usually the
+ * property name). `indent` is where the nested declarations are placed.
+ */
+function renderTypeRef(schema, nameHint, indent, state) {
+    const d = describeSchema(schema);
+    // Discriminated union → a named enum type.
+    if (d.oneOf) {
+        if (d.oneOf.kind === "invalid") {
+            state.fail(`swift codegen: ${d.oneOf.reason}`);
+        }
+        const typeName = structTypeName(nameHint);
+        const decl = renderOneOfEnum(typeName, d.oneOf, indent, {
+            ...state,
+            path: `${state.path}.${nameHint}`,
+        });
+        return { expr: typeName, nullable: false, decls: [decl] };
+    }
+    // Scalar `enum`.
+    if (d.enumValues) {
+        return renderEnumRef(d, nameHint, indent, state);
+    }
+    // Type union (e.g. `["string","null"]`).
+    if (d.isUnion) {
+        return renderUnionRef(d);
+    }
+    // No usable single type, not an enum/union/oneOf → un-descended → JSONValue.
+    if (d.singularType === null) {
+        return { expr: "JSONValue", nullable: false, decls: [] };
+    }
+    if (d.singularType === "object") {
+        if (d.object) {
+            const typeName = structTypeName(nameHint);
+            const decl = renderStruct(typeName, d.object, indent, {
+                ...state,
+                path: `${state.path}.${nameHint}`,
+            });
+            return { expr: typeName, nullable: false, decls: [decl] };
+        }
+        // Open object with no declared properties → an untyped dictionary.
+        return { expr: "[String: JSONValue]", nullable: false, decls: [] };
+    }
+    if (d.singularType === "array") {
+        const items = d.array ? d.array.items : undefined;
+        // Missing or tuple `items` (array of schemas) is not descended → [JSONValue].
+        if (!items || typeof items !== "object" || Array.isArray(items)) {
+            return { expr: "[JSONValue]", nullable: false, decls: [] };
+        }
+        const elem = renderTypeRef(items, `${nameHint}Item`, indent, {
+            ...state,
+            path: `${state.path}.${nameHint}[]`,
+        });
+        return {
+            expr: `[${optionalize(elem)}]`,
+            nullable: false,
+            decls: elem.decls,
+        };
+    }
+    // `null` singular type, or an unknown/unmodeled type name → JSONValue.
+    const scalar = SCALAR_SWIFT[d.singularType];
+    if (scalar)
+        return { expr: scalar, nullable: false, decls: [] };
+    return {
+        expr: "JSONValue",
+        nullable: d.singularType === "null",
+        decls: [],
+    };
+}
+/**
+ * Render a scalar `enum` node. All-string members → a nested `String` enum;
+ * an empty reachable set → `never` (codegen error); anything else (mixed-type
+ * or non-string scalars) → `JSONValue` (Fork 4).
+ */
+function renderEnumRef(d, nameHint, indent, state) {
+    const decl = renderStringEnumIfApplicable(d, enumTypeName(nameHint), indent, state);
+    if (decl) {
+        return { expr: enumTypeName(nameHint), nullable: false, decls: [decl] };
+    }
+    // Not an all-string enum: mixed-type or non-string scalar values fall back to
+    // JSONValue (faithful to TS `unknown`). A `null` member makes the node
+    // nullable, which JSONValue already covers.
+    const hasNull = (d.enumValues ?? []).includes(null);
+    return { expr: "JSONValue", nullable: hasNull, decls: [] };
+}
+/**
+ * If `d` is a scalar `enum` whose reachable members (after the type gate) are
+ * ALL strings, return a nested `String` enum declaration named `typeName`.
+ * Returns `null` when it is not an all-string enum. Throws on an uninhabitable
+ * (`never`) enum.
+ */
+function renderStringEnumIfApplicable(d, typeName, indent, state) {
+    if (!d.enumValues)
+        return null;
+    const allowedTypes = d.types;
+    const candidates = allowedTypes.length > 0
+        ? d.enumValues.filter((v) => allowedTypes.some((t) => isType(v, t)))
+        : d.enumValues;
+    if (candidates.length === 0) {
+        // No enum member satisfies the declared type gate: the runtime rejects
+        // every value. This is `never` on the TS side; a Swift field that can never
+        // be constructed is a strict codegen error (Fork 4).
+        state.fail("swift codegen: enum has no value satisfying its declared type (uninhabitable / never)");
+    }
+    const allStrings = candidates.every((v) => typeof v === "string");
+    if (!allStrings)
+        return null;
+    const cases = enumCaseNames(candidates);
+    const pad = INDENT_UNIT.repeat(indent);
+    const inner = INDENT_UNIT.repeat(indent + 1);
+    const lines = [];
+    // Conformance list matches the Swift model codegen's nested enums
+    // (`String, Codable, CaseIterable, Sendable`). A String-raw enum is implicitly
+    // Equatable, so an enclosing struct's synthesized Equatable still works.
+    lines.push(`${pad}${ACCESS} enum ${typeName}: String, Codable, CaseIterable, Sendable {`);
+    for (const c of cases) {
+        lines.push(`${inner}case ${c.name} = ${swiftString(c.raw)}`);
+    }
+    lines.push(`${pad}}`);
+    return lines.join("\n");
+}
+/**
+ * Render a type union (`type: [...]`). A single non-null scalar (optionally with
+ * `null`) → that scalar (nullable if `null` present). Multiple distinct scalars,
+ * or any object/array member → `JSONValue` (no untagged union in Swift).
+ */
+function renderUnionRef(d) {
+    const hasNull = d.types.includes("null");
+    const nonNull = d.types.filter((t) => t !== "null");
+    const mapped = [];
+    for (const t of nonNull) {
+        const s = SCALAR_SWIFT[t];
+        if (!s) {
+            // object / array / unknown member → not representable as a Swift union.
+            return { expr: "JSONValue", nullable: hasNull, decls: [] };
+        }
+        if (!mapped.includes(s))
+            mapped.push(s);
+    }
+    if (mapped.length === 0) {
+        // `["null"]` only → JSONValue (which includes null).
+        return { expr: "JSONValue", nullable: true, decls: [] };
+    }
+    if (mapped.length === 1) {
+        return { expr: mapped[0], nullable: hasNull, decls: [] };
+    }
+    // Multi-scalar non-null union (e.g. ["string","number"]) → JSONValue (Fork 4).
+    return { expr: "JSONValue", nullable: hasNull, decls: [] };
+}
+/**
+ * Render an object descriptor as a Swift `struct`. `required[]` drives
+ * optionality; an open object gains an `extra: [String: JSONValue]` catch-all.
+ * Emits a public memberwise initializer always, `CodingKeys` when a wire key
+ * isn't its Swift name (or when custom Codable is needed), and custom
+ * `init(from:)`/`encode(to:)` when required-nullable properties or the
+ * open-object catch-all require it.
+ */
+function renderStruct(typeName, objectDesc, indent, state, forcedRequired = []) {
+    const { properties, required, additionalPropertiesClosed } = objectDesc;
+    const requiredSet = new Set([
+        ...(Array.isArray(required)
+            ? required.filter((k) => typeof k === "string")
+            : []),
+        ...forcedRequired,
+    ]);
+    const isOpen = !additionalPropertiesClosed;
+    const nestedDecls = [];
+    const usedTypeNames = new Set();
+    const props = [];
+    const usedSwiftNames = new Set();
+    const recordName = (name) => {
+        const bare = unescapeIdentifier(name);
+        if (usedSwiftNames.has(bare)) {
+            state.fail(`swift codegen: two properties map to the same Swift name \`${bare}\``);
+        }
+        usedSwiftNames.add(bare);
+    };
+    for (const wireKey of Object.keys(properties)) {
+        const ref = renderTypeRef(properties[wireKey], wireKey, indent + 1, {
+            ...state,
+            path: `${state.path}.${wireKey}`,
+        });
+        for (const decl of ref.decls) {
+            // Nested type names live in the struct body; a collision is a codegen error.
+            const declName = declTypeName(decl);
+            if (declName) {
+                if (usedTypeNames.has(declName)) {
+                    state.fail(`swift codegen: two nested types resolve to the same name \`${declName}\``);
+                }
+                usedTypeNames.add(declName);
+            }
+            nestedDecls.push(decl);
+        }
+        const swiftName = swiftPropertyName(wireKey);
+        recordName(swiftName);
+        const isRequired = requiredSet.has(wireKey);
+        props.push({
+            wireKey,
+            swiftName,
+            type: ref.expr,
+            optionalType: !isRequired || ref.nullable,
+            requiredNullable: isRequired && ref.nullable,
+            requiredNonNull: isRequired && !ref.nullable,
+        });
+    }
+    // A key listed in `required` but absent from `properties` has no child schema,
+    // yet the validator still rejects an object missing it. Emit it as a required
+    // `JSONValue` member so the generated type demands the key too.
+    for (const wireKey of requiredSet) {
+        if (Object.prototype.hasOwnProperty.call(properties, wireKey))
+            continue;
+        const swiftName = swiftPropertyName(wireKey);
+        recordName(swiftName);
+        props.push({
+            wireKey,
+            swiftName,
+            type: "JSONValue",
+            optionalType: false,
+            requiredNullable: false,
+            requiredNonNull: true,
+        });
+    }
+    // An open object gains a catch-all stored property. Its Swift name must not
+    // collide with a modelled property (a wire key literally named `extra` is
+    // plausible), so pick the first free candidate and reserve it. If every
+    // candidate is taken, fail with a named error rather than emit a struct with
+    // two `var extra` declarations that will not compile.
+    let catchAllName = "";
+    if (isOpen) {
+        const candidates = ["extra", "additionalProperties", "extraProperties"];
+        catchAllName = candidates.find((c) => !usedSwiftNames.has(c)) ?? "";
+        if (catchAllName === "") {
+            state.fail(`swift codegen: cannot name the open-object catch-all for \`${typeName}\` — ` +
+                `properties already use every candidate name (${candidates.join(", ")})`);
+        }
+        usedSwiftNames.add(catchAllName);
+    }
+    const needsCustomCodable = isOpen || props.some((p) => p.requiredNullable);
+    const needsCodingKeys = needsCustomCodable ||
+        props.some((p) => unescapeIdentifier(p.swiftName) !== p.wireKey);
+    const pad = INDENT_UNIT.repeat(indent);
+    const b = INDENT_UNIT.repeat(indent + 1);
+    const out = [];
+    out.push(`${pad}${ACCESS} struct ${typeName}: ${CONFORMANCES} {`);
+    // Nested type declarations first (already rendered at indent + 1).
+    for (const decl of nestedDecls) {
+        out.push(decl);
+    }
+    if (nestedDecls.length > 0)
+        out.push("");
+    // Stored properties.
+    for (const p of props) {
+        out.push(`${b}${ACCESS} var ${p.swiftName}: ${p.type}${p.optionalType ? "?" : ""}`);
+    }
+    if (isOpen) {
+        out.push(`${b}/// Extra keys the schema does not model, preserved round-trip.`);
+        out.push(`${b}${ACCESS} var ${catchAllName}: [String: JSONValue]`);
+    }
+    out.push("");
+    // Public memberwise initializer (synthesized memberwise init is not public
+    // across module boundaries — binding item 4).
+    out.push(renderMemberwiseInit(props, isOpen, catchAllName, indent + 1));
+    // CodingKeys.
+    if (needsCodingKeys) {
+        out.push("");
+        out.push(renderCodingKeys(props, indent + 1));
+    }
+    // Custom Codable when required-nullable or open-object catch-all needs it.
+    if (needsCustomCodable) {
+        out.push("");
+        out.push(renderCustomDecodeEncode(props, isOpen, catchAllName, indent + 1));
+    }
+    out.push(`${pad}}`);
+    return out.join("\n");
+}
+function renderMemberwiseInit(props, isOpen, catchAllName, indent) {
+    const pad = INDENT_UNIT.repeat(indent);
+    const body = INDENT_UNIT.repeat(indent + 1);
+    const params = [];
+    for (const p of props) {
+        const type = `${p.type}${p.optionalType ? "?" : ""}`;
+        // Optional-typed params default to nil for ergonomics.
+        params.push(`${p.swiftName}: ${type}${p.optionalType ? " = nil" : ""}`);
+    }
+    if (isOpen)
+        params.push(`${catchAllName}: [String: JSONValue] = [:]`);
+    const lines = [];
+    if (params.length === 0) {
+        lines.push(`${pad}${ACCESS} init() {}`);
+        return lines.join("\n");
+    }
+    lines.push(`${pad}${ACCESS} init(`);
+    params.forEach((param, i) => {
+        lines.push(`${body}${param}${i < params.length - 1 ? "," : ""}`);
+    });
+    lines.push(`${pad}) {`);
+    for (const p of props) {
+        lines.push(`${body}self.${p.swiftName} = ${p.swiftName}`);
+    }
+    if (isOpen)
+        lines.push(`${body}self.${catchAllName} = ${catchAllName}`);
+    lines.push(`${pad}}`);
+    return lines.join("\n");
+}
+function renderCodingKeys(props, indent) {
+    const pad = INDENT_UNIT.repeat(indent);
+    const body = INDENT_UNIT.repeat(indent + 1);
+    const lines = [];
+    lines.push(`${pad}${ACCESS} enum CodingKeys: String, CodingKey {`);
+    for (const p of props) {
+        const bare = unescapeIdentifier(p.swiftName);
+        const rhs = bare !== p.wireKey ? ` = ${swiftString(p.wireKey)}` : "";
+        lines.push(`${body}case ${p.swiftName}${rhs}`);
+    }
+    lines.push(`${pad}}`);
+    return lines.join("\n");
+}
+/**
+ * Custom `init(from:)`/`encode(to:)` for a struct that needs explicit-null
+ * encoding (required-nullable) or an open-object `extra` catch-all.
+ */
+function renderCustomDecodeEncode(props, isOpen, catchAllName, indent) {
+    const pad = INDENT_UNIT.repeat(indent);
+    const b = INDENT_UNIT.repeat(indent + 1);
+    const b2 = INDENT_UNIT.repeat(indent + 2);
+    const lines = [];
+    // Decode.
+    lines.push(`${pad}${ACCESS} init(from decoder: Decoder) throws {`);
+    lines.push(`${b}let container = try decoder.container(keyedBy: CodingKeys.self)`);
+    for (const p of props) {
+        if (p.requiredNonNull) {
+            lines.push(`${b}self.${p.swiftName} = try container.decode(${p.type}.self, forKey: .${p.swiftName})`);
+        }
+        else {
+            // Optional or required-nullable: lenient decode (a missing key → nil).
+            lines.push(`${b}self.${p.swiftName} = try container.decodeIfPresent(${p.type}.self, forKey: .${p.swiftName})`);
+        }
+    }
+    if (isOpen) {
+        lines.push(`${b}let dynamic = try decoder.container(keyedBy: DynamicCodingKey.self)`);
+        lines.push(`${b}var collected: [String: JSONValue] = [:]`);
+        lines.push(`${b}for key in dynamic.allKeys where !Self.knownKeys.contains(key.stringValue) {`);
+        lines.push(`${b2}collected[key.stringValue] = try dynamic.decode(JSONValue.self, forKey: key)`);
+        lines.push(`${b}}`);
+        lines.push(`${b}self.${catchAllName} = collected`);
+    }
+    lines.push(`${pad}}`);
+    lines.push("");
+    // Encode.
+    lines.push(`${pad}${ACCESS} func encode(to encoder: Encoder) throws {`);
+    lines.push(`${b}var container = encoder.container(keyedBy: CodingKeys.self)`);
+    for (const p of props) {
+        if (p.requiredNonNull || p.requiredNullable) {
+            // Required: always encode the key. For required-nullable this writes an
+            // EXPLICIT null when the value is nil (so server required-key validation
+            // still sees the key).
+            lines.push(`${b}try container.encode(${p.swiftName}, forKey: .${p.swiftName})`);
+        }
+        else {
+            // Pure optional: omit the key when nil.
+            lines.push(`${b}try container.encodeIfPresent(${p.swiftName}, forKey: .${p.swiftName})`);
+        }
+    }
+    if (isOpen) {
+        lines.push(`${b}var dynamic = encoder.container(keyedBy: DynamicCodingKey.self)`);
+        lines.push(`${b}for (key, value) in ${catchAllName} where !Self.knownKeys.contains(key) {`);
+        lines.push(`${b2}try dynamic.encode(value, forKey: DynamicCodingKey(stringValue: key))`);
+        lines.push(`${b}}`);
+    }
+    lines.push(`${pad}}`);
+    if (isOpen) {
+        const wireKeys = props.map((p) => swiftString(p.wireKey)).join(", ");
+        lines.push("");
+        lines.push(`${pad}private static let knownKeys: Set<String> = [${wireKeys}]`);
+        lines.push("");
+        lines.push(`${pad}private struct DynamicCodingKey: CodingKey {`);
+        lines.push(`${b}var stringValue: String`);
+        lines.push(`${b}var intValue: Int? { nil }`);
+        lines.push(`${b}init(stringValue: String) { self.stringValue = stringValue }`);
+        lines.push(`${b}init?(intValue: Int) { nil }`);
+        lines.push(`${pad}}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Render a valid `oneOf` discriminated union as a Swift `enum` with associated
+ * values plus a generated `init(from:)`/`encode(to:)`. Each branch `struct`
+ * carries the discriminator (forced required) as a single-case `String` enum, so
+ * decoding a branch rejects a conflicting discriminator value and encoding
+ * re-emits the tag (binding item 4).
+ */
+function renderOneOfEnum(typeName, oneOf, indent, state) {
+    const pad = INDENT_UNIT.repeat(indent);
+    const b = INDENT_UNIT.repeat(indent + 1);
+    const b2 = INDENT_UNIT.repeat(indent + 2);
+    const b3 = INDENT_UNIT.repeat(indent + 3);
+    const { discriminant, members } = oneOf;
+    // Assign each branch a case name (deduped) and a branch struct type name.
+    const usedCaseNames = new Map();
+    const usedBranchTypes = new Set();
+    const branches = members.map((m) => {
+        const valueStr = String(m.discriminantValue);
+        // Case name derived from the discriminator value, deduped. Dedup on the
+        // UN-escaped base and re-escape once, so a reserved-word discriminator
+        // (`default`) that collides gets `default_2`, not the uncompilable
+        // `` `default`_2 `` (suffix outside the backticks).
+        const bareCase = unescapeIdentifier(enumCaseIdentifier(valueStr));
+        const count = usedCaseNames.get(bareCase) ?? 0;
+        usedCaseNames.set(bareCase, count + 1);
+        const caseName = escapeIfReserved(count === 0 ? bareCase : `${bareCase}_${count + 1}`);
+        let branchType = structTypeName(`${valueStr}Branch`);
+        while (usedBranchTypes.has(branchType))
+            branchType = `${branchType}_`;
+        usedBranchTypes.add(branchType);
+        return { caseName, branchType, member: m };
+    });
+    const lines = [];
+    lines.push(`${pad}${ACCESS} enum ${typeName}: ${CONFORMANCES} {`);
+    for (const br of branches) {
+        lines.push(`${b}case ${br.caseName}(${br.branchType})`);
+    }
+    lines.push("");
+    // Nested branch structs. Each renders from its member object descriptor with
+    // the discriminant forced required.
+    for (const br of branches) {
+        const md = describeSchema(br.member.schema);
+        if (!md.object) {
+            // Guaranteed by the descriptor (every member is `type: "object"`), but be
+            // defensive rather than emit broken Swift.
+            state.fail(`swift codegen: oneOf branch for ${discriminant}=${String(br.member.discriminantValue)} is not an object`);
+        }
+        const decl = renderStruct(br.branchType, md.object, indent + 1, { ...state, path: `${state.path}.${br.branchType}` }, [discriminant]);
+        lines.push(decl);
+        lines.push("");
+    }
+    // Discriminator coding key.
+    const tagKind = discriminatorTagKind(members.map((m) => m.discriminantValue));
+    lines.push(`${b}private enum DiscriminatorKey: String, CodingKey {`);
+    lines.push(`${b2}case tag = ${swiftString(discriminant)}`);
+    lines.push(`${b}}`);
+    lines.push("");
+    // init(from:) — read the tag, select the branch (which re-validates the tag).
+    lines.push(`${b}${ACCESS} init(from decoder: Decoder) throws {`);
+    lines.push(`${b2}let container = try decoder.container(keyedBy: DiscriminatorKey.self)`);
+    if (tagKind.kind === "scalar") {
+        lines.push(`${b2}let tag = try container.decode(${tagKind.swiftType}.self, forKey: .tag)`);
+        lines.push(`${b2}switch tag {`);
+        for (const br of branches) {
+            lines.push(`${b2}case ${tagKind.literal(br.member.discriminantValue)}:`);
+            lines.push(`${b3}self = .${br.caseName}(try ${br.branchType}(from: decoder))`);
+        }
+        lines.push(`${b2}default:`);
+        lines.push(`${b3}throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: ${swiftString(`Unknown ${discriminant} discriminator for ${typeName}`)}))`);
+        lines.push(`${b2}}`);
+    }
+    else {
+        // Mixed-type discriminator values → decode as JSONValue and compare.
+        lines.push(`${b2}let tag = try container.decode(JSONValue.self, forKey: .tag)`);
+        branches.forEach((br, i) => {
+            const kw = i === 0 ? "if" : "} else if";
+            lines.push(`${b2}${kw} tag == ${jsonValueLiteral(br.member.discriminantValue)} {`);
+            lines.push(`${b3}self = .${br.caseName}(try ${br.branchType}(from: decoder))`);
+        });
+        lines.push(`${b2}} else {`);
+        lines.push(`${b3}throw DecodingError.dataCorrupted(.init(codingPath: decoder.codingPath, debugDescription: ${swiftString(`Unknown ${discriminant} discriminator for ${typeName}`)}))`);
+        lines.push(`${b2}}`);
+    }
+    lines.push(`${b}}`);
+    lines.push("");
+    // encode(to:) — delegate to the branch (which re-emits the tag).
+    lines.push(`${b}${ACCESS} func encode(to encoder: Encoder) throws {`);
+    lines.push(`${b2}switch self {`);
+    for (const br of branches) {
+        lines.push(`${b2}case .${br.caseName}(let value):`);
+        lines.push(`${b3}try value.encode(to: encoder)`);
+    }
+    lines.push(`${b2}}`);
+    lines.push(`${b}}`);
+    lines.push(`${pad}}`);
+    return lines.join("\n");
+}
+/** Determine how to decode + match a set of discriminator literals. */
+function discriminatorTagKind(values) {
+    if (values.every((v) => typeof v === "string")) {
+        return { kind: "scalar", swiftType: "String", literal: (v) => swiftString(v) };
+    }
+    if (values.every((v) => typeof v === "number")) {
+        return { kind: "scalar", swiftType: "Double", literal: (v) => `${v}` };
+    }
+    if (values.every((v) => typeof v === "boolean")) {
+        return { kind: "scalar", swiftType: "Bool", literal: (v) => `${v}` };
+    }
+    return { kind: "mixed" };
+}
+/** A `JSONValue` literal for a scalar discriminator (mixed-type branch). */
+function jsonValueLiteral(v) {
+    if (typeof v === "string")
+        return `JSONValue.string(${swiftString(v)})`;
+    if (typeof v === "number")
+        return `JSONValue.number(${v})`;
+    if (typeof v === "boolean")
+        return `JSONValue.bool(${v})`;
+    return "JSONValue.null";
+}
+/** Extract the declared type name from a `struct`/`enum` declaration's first line. */
+function declTypeName(decl) {
+    const firstLine = decl.split("\n").find((l) => l.trim().length > 0) ?? "";
+    const m = firstLine.match(/\b(?:struct|enum)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return m ? m[1] : null;
+}
+//# sourceMappingURL=schemaToSwift.js.map