@shipworthy/openapi-zod 0.0.2 → 1.0.0

package/README.md

@@ -8,18 +8,19 @@ Generate [Zod 4](https://zod.dev) validators from an OpenAPI 3.1 document. Every
 bun add -d @shipworthy/openapi-zod @shipworthy/openapi-cli
 ```
 
-The generator and generated file both import `zod`. It is a required peer dependency of this package, so install this exact version as your app's runtime dependency:
+The generator checks schemas with `zod`, and the generated file imports it. It is a required peer dependency of this package, so install this exact version in the package that owns the generated file:
 
 ```sh
-bun add zod@4.6.5
+bun add zod@4.6.7
 ```
 
 Requirements:
 
-- **Zod 4.6.5.** The generated code calls `z.fromJSONSchema` and `z.compile`. `fromJSONSchema` is experimental in Zod, so the package pins `zod@4.6.5`. Use the same version in your app.
+- **Zod 4.6.7.** The generated code calls `z.fromJSONSchema` and `z.compile`. `fromJSONSchema` is experimental in Zod, so the package pins `zod@4.6.7`. Use the same version in your app.
 - **Node.js `>=22.19.0` or Bun.** The package ships compiled JavaScript and `.d.ts` declarations in `dist/`, so no TypeScript loader or bundler is needed. The `openapi` CLI runs on Node.js or Bun (`bunx --bun @shipworthy/openapi-cli ...`).
 - **ESM only.** The package sets `"type": "module"` and has a single `.` export. There is no CommonJS build.
-- **Peer dependency.** `zod` `4.6.5`, shared by the generator and your app. npm 7+ installs peers automatically, but install it explicitly as shown above.
+- **Peer dependency.** `zod` `4.6.7`. npm 7+ installs peers automatically, but install it explicitly as shown above.
+- **Workspace resolution.** The CLI looks for an installed Zod from the output directory upward. If none is installed there, it uses the generator's installation; Bun's global auto-install cache does not count as an installed package. A different installed version fails with the found version and resolved path before schema compilation. Install `zod@4.6.7` in the package that will import the generated file.
 - **Installed dependencies.** The package installs `effect`, `@shipworthy/openapi-generator`, `@shipworthy/openapi-transformer`, and `@shipworthy/openapi-typescript`.
 
 Install `@shipworthy/openapi-cli` only if you use the CLI. For programmatic examples, also install the packages you import directly (`@shipworthy/openapi-generator`, `@shipworthy/openapi-transformer`, and `@effect/platform-node` as needed).
@@ -78,13 +79,12 @@ Run the `openapi` commands below in a package script, or use `bunx --bun @shipwo
 Generate:
 
 ```sh
-bunx --bun @shipworthy/openapi-cli generate zod ./openapi.json -o ./src/generated/hotels/zod-schema.ts
+bunx --bun @shipworthy/openapi-cli generate zod -i ./openapi.json -o ./src/generated/hotels
 ```
 
 ```text
-openapi generate typescript 0.0.1
-file:///…/openapi.json → /…/src/generated/hotels/types.ts [49ms]
-file:///…/openapi.json → /…/src/generated/hotels/zod-schema.ts [71ms]
+file:///…/openapi.json → ./src/generated/hotels/types.ts […]
+file:///…/openapi.json → ./src/generated/hotels/zod-schema.ts […]
 ```
 
 Use:
@@ -101,23 +101,26 @@ result.success; // false: name has minLength 1
 
 ## CLI: `openapi generate zod`
 
-The command comes from `@shipworthy/openapi-cli`.
+The command comes from `@shipworthy/openapi-cli`. The `zod` plugin writes `zod-schema.ts` and the `types.ts` it imports into the output directory:
 
 ```text
-openapi generate zod [flags] <input>
+openapi generate zod [-i <input>] -o <dir> [--camel-case] [--wire-types] [--check] [TypeScript flags]
 ```
 
-| Argument / flag  | Type    | Default  | Description                                                                                                                          |
+| Flag             | Type    | Default  | Description                                                                                                                          |
 | ---------------- | ------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `<input>`        | string  | required | OpenAPI schema file path or URL (`http:`, `https:`, `file:`). JSON or YAML. Globs (`*`) are rejected with `Globbing is unsupported.` |
-| `--output`, `-o` | string  | required | Output file for the Zod module. `types.ts` is written to the same directory.                                                         |
-| `--force`        | boolean | `false`  | Regenerate `types.ts` even when its stamp matches.                                                                                   |
+| `--input`, `-i`  | string  | stdin    | OpenAPI schema file path or URL (`http:`, `https:`, `file:`). JSON or YAML. Globs (`*`) are rejected with `Globbing is unsupported.` |
+| `--output`, `-o` | string  | required | Output directory. Receives `zod-schema.ts` and `types.ts`. Required because the run writes two files.                                |
+| `--camel-case`   | boolean | `false`  | Generate camelCase `types.ts` and camelCase validators. See [camelCase](#camelcase).                                                 |
+| `--check`        | boolean | `false`  | Write nothing; exit 1 when `zod-schema.ts` or `types.ts` differs from the generated output or is missing.                            |
+
+The TypeScript generator flags, such as `--no-array-length`, `--enum`, and `--root-types`, apply to `types.ts`. The `zod` plugin can be combined with other plugins in one run, for example `openapi generate zod tanstack-query -i openapi.json -o src/generated/hotels`, which writes one shared `types.ts`. See the [CLI reference](../openapi-cli/README.md#openapi-generate-plugins) for every flag, including `--wire-types`.
 
 What the command does:
 
-1. **Ensures `types.ts`.** It looks for `types.ts` next to the output file. If that file is missing, or its header stamp is not `@shipworthy/openapi-typescript@<version>:<sha256 of the input>`, it runs the TypeScript generator with default flags and writes `types.ts`. With `--force` it always rewrites `types.ts`.
-2. **Generates the Zod module.** It loads, bundles, and validates the input. Bundling resolves external `$ref`s and upgrades OpenAPI 3.0 documents to 3.1. It then runs the `zod` generator.
-3. **Writes the output.** It prepends a header and creates parent directories as needed. An existing output file is overwritten.
+1. **Loads the input.** It loads, bundles, and validates the input once. Bundling resolves external `$ref`s and upgrades OpenAPI 3.0 documents to 3.1.
+2. **Generates `types.ts` and the Zod module.** It runs the TypeScript generator with the TypeScript flags and the `zod` generator. Both files are regenerated on every run.
+3. **Writes the output.** Only after both files were generated, it prepends a header to each and writes them, creating the output directory as needed. Existing files are overwritten.
 
 Generated file header:
 
@@ -130,13 +133,13 @@ Generated file header:
  */
 ```
 
-The stamp line is `<package>@<version>:<sha256 of the input file contents>`.
+The stamp line is `<package>@<version>:<sha256 of the input file contents>`. With `--camel-case`, a `Field casing: camelCase` line follows the stamp, and the hash also covers the casing setting.
 
-On failure the command prints `ERROR` and the message, then exits with code 1. The Zod file is not written. `types.ts` is generated first, so it can already exist when the Zod step fails. Example:
+On failure the command prints `ERROR` and the message, then exits with code 1. Neither `zod-schema.ts` nor `types.ts` is written. Example:
 
 ```text
 ERROR
-  #/components/schemas/Guest/properties/name: Unsupported keyword discriminator
+  #/components/schemas/Guest/properties/name: Unsupported keyword if
 ```
 
 A typical `package.json` script:
@@ -144,7 +147,7 @@ A typical `package.json` script:
 ```json
 {
   "scripts": {
-    "generate": "openapi generate zod openapi.json -o src/generated/hotels/zod-schema.ts"
+    "generate": "openapi generate zod -i openapi.json -o src/generated/hotels"
   }
 }
 ```
@@ -172,7 +175,12 @@ const zod: Generator<ZodSource, ZodGenerationError>;
 // { id: "zod", generate(model: ParsedService, options): Effect<ZodSource, ZodGenerationError> }
 ```
 
-The generator plugin. `Generator` is from `@shipworthy/openapi-generator`. `generate` ignores `options` and runs `operationRoutes(model)` followed by `zodSources(model, routes)`. The CLI loads this export by name (`exportName: "zod"`).
+The generator plugin. `Generator` is from `@shipworthy/openapi-generator`. `generate` accepts these options:
+
+- `outputPath?: string`: resolve Zod from the generated file's location. Without it, Zod is resolved from the generator's installation.
+- `camelCase?: boolean`: rename snake_case properties to camelCase. See [camelCase](#camelcase). Default `false`.
+
+It then runs `operationRoutes(model)` followed by `zodSources(model, routes, options)`. Options of the wrong type fail with `ZodGenerationError` (`#: Invalid generator options`). Unknown option keys are ignored. The CLI loads this export by name (`exportName: "zod"`).
 
 The usual way to run it from code is `generate` from `@shipworthy/openapi-generator`. That function reads the source, bundles external refs, upgrades 3.0 to 3.1, and decodes the model:
 
@@ -188,6 +196,7 @@ const source = await Effect.runPromise(
     specifier: "@shipworthy/openapi-zod",
     exportName: "zod",
     source: pathToFileURL("./openapi.json"),
+    pluginOptions: { outputPath: "./src/generated/zod-schema.ts" },
   }).pipe(
     Effect.provideService(ModuleLoader, { load: (specifier) => import(specifier) }),
     Effect.provide(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer)),
@@ -205,21 +214,32 @@ import { zod } from "@shipworthy/openapi-zod";
 import { Effect } from "effect";
 
 const model = Effect.runSync(decode(document));
-const source = Effect.runSync(zod.generate(model, {}));
+const source = Effect.runSync(zod.generate(model, { outputPath: "./src/generated/zod-schema.ts" }));
 ```
 
 Write `source` next to a `types.ts` generated by `@shipworthy/openapi-typescript` from the same document.
 
-### `zodSources(document, routes)`
+### `zodSources(document, routes, options?)`
 
 ```ts
 const zodSources: (
   document: ParsedService,
   routes: Record<string, OperationRoute>,
+  options?: { readonly outputPath?: string; readonly camelCase?: boolean },
 ) => Effect<ZodSource, ZodGenerationError>;
 ```
 
-Turns a parsed OpenAPI 3.1 model into Zod module source. `routes` selects which operations can produce a `<operationId>RequestBody` validator. An operation whose `operationId` is not a key of `routes` is skipped. Build the table with `operationRoutes`. It fails with `ZodGenerationError` for anything listed under [Limitations](#limitations). Returns `""` when there are no component schemas and no JSON request bodies.
+Turns a parsed OpenAPI 3.1 model into Zod module source. `routes` selects which operations can produce a `<operationId>RequestBody` validator. An operation whose `operationId` is not a key of `routes` is skipped. Build the table with `operationRoutes`. Set `options.outputPath` to resolve Zod from the generated file's location; without it, generation uses the generator's own Zod. It fails with `ZodGenerationError` for anything listed under [Limitations](#limitations). Returns `""` when there are no component schemas and no JSON request bodies.
+
+#### camelCase
+
+Set `camelCase: true` when the validators sit next to a `types.ts` that `@shipworthy/openapi-typescript` generated with `camelCase: true`. The validators then accept and return the camelCase shapes those types declare. The CLI flag `--camel-case` sets this option and generates the matching camelCase `types.ts` in the same run.
+
+- Renamed: lower snake_case names (`first_name`, `address_line_2`) in `properties` keys, `required` entries, `dependentRequired`, and the discriminator `propertyName`. This applies at every depth, in component schemas and request bodies alike. Other names, such as `already_Camel`, `_private`, or `UPPER_CASE`, keep their spelling.
+- Kept: `enum` and `const` values, discriminator mapping values, `patternProperties` keys, and `$ref`s keep the API spelling. A `patternProperties` pattern therefore still matches the API's snake_case keys.
+- Collisions: when two names at one object level become the same name, including names merged through `allOf`, `anyOf`, `oneOf`, or a `$ref`, generation fails before any output is produced. The message is `<path>: user_id and userId both become userId`, where `<path>` is the component pointer (`#/components/schemas/User`) or the operation (`POST /users`).
+
+The validators check camelCase objects. Convert wire payloads to camelCase before you parse them with the same mapping the client uses. The generated module still imports `./types` and casts each export to `components["schemas"][Name]` or the operation's request body type.
 
 ### `operationRoutes(model)`
 
@@ -280,14 +300,18 @@ with the affected export name and validation error.
 
 ## Supported schemas
 
-- **OpenAPI version.** The generator requires `openapi: 3.1.x` on the model. Through the CLI or `generate()`, 3.0 documents are upgraded to 3.1 first. The 3.0 upgrade does not remove keywords such as `discriminator`, and those still fail (see Limitations).
-- **Validation keywords:** `$ref`, `type`, `enum`, `const`, `properties`, `patternProperties`, `additionalProperties`, `propertyNames`, `required`, `minProperties`, `maxProperties`, `allOf`, `anyOf`, `oneOf`, `items`, `prefixItems`, `contains`, `minContains`, `maxContains`, `minItems`, `maxItems`, `uniqueItems`, `minLength`, `maxLength`, `pattern`, `format`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`.
+- **OpenAPI version.** The generator requires `openapi: 3.1.x` on the model. Through the CLI or `generate()`, 3.0 documents are upgraded to 3.1 first.
+- **Validation keywords:** `$ref`, `type`, `enum`, `const`, `properties`, `patternProperties`, `additionalProperties`, `propertyNames`, `required`, `minProperties`, `maxProperties`, `allOf`, `anyOf`, `oneOf`, `discriminator`, `items`, `prefixItems`, `contains`, `minContains`, `maxContains`, `minItems`, `maxItems`, `uniqueItems`, `minLength`, `maxLength`, `pattern`, `format`, `minimum`, `maximum`, `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`.
 - **Annotations, allowed and passed through:** `title`, `description`, `default` (stripped), `example`, `examples`, `deprecated`, `readOnly`, `writeOnly`, `$comment`, `externalDocs`, `xml`, and any `x-*` extension.
 - **Boolean schemas.** `true` and `false` are supported.
 - **Rewrites for Zod.** Some JSON Schema patterns are rewritten so Zod enforces them:
   - `dependentRequired` is rewritten into `allOf` branches. Example: `{ payment_source_id: ["hold_id"] }` requires `hold_id` only when `payment_source_id` is present.
   - A required-only `allOf` branch such as `{ required: ["name"] }` copies in the property schemas inherited from sibling branches, so the requirement is enforced.
   - `not: { anyOf: [{ required: ["k"] }, …] }`, when it stands alone in an object `allOf` branch, forbids those keys.
+  - A `discriminator` on `oneOf` or `anyOf` constrains each component `$ref` branch to its mapped property values. Multiple values can map to one branch. Without a mapping for a branch, its schema name is the implicit value unless that value explicitly maps to a different branch. A component reused by several unions with the same discriminator property accepts their combined mapped values. If the unions use different properties, the component alone remains general and each union branch enforces its own tag.
+  - Discriminated unions are closed: a value absent from the mapping and implicit branch names is rejected. Regenerate the SDK when the service adds a new value. For an invalid payload with a known value, the exported union validator reports the selected branch's issues directly, such as a missing `auth_url` at `path: ["auth_url"]`.
+  - Existing constraints on a discriminator property remain in effect. A mapping value that conflicts with them is rejected by the validator.
+  - When a component extends a parent with a `discriminator` through `allOf`, the child receives values mapped to it, or its schema name when no mapping entry exists. The parent remains a general validator.
 - **External refs.** External `$ref`s (local files or URLs) are bundled before conversion when you use the CLI or `generate()`.
 
 ## Limitations
@@ -300,7 +324,10 @@ Generation fails with `ZodGenerationError` when it finds any of the following:
 | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
 | Model `openapi` not `3.1.x`                                                                     | `Zod generation requires OpenAPI 3.1`                                          |
 | `jsonSchemaDialect` set, or top-level `$defs`                                                   | `Zod generation does not support custom dialects or top-level $defs`           |
-| Any keyword not listed above, e.g. `discriminator`, `if`/`then`/`else`, `unevaluatedProperties` | `<path>: Unsupported keyword <key>`                                            |
+| Any keyword not listed above, e.g. `if`/`then`/`else`, `unevaluatedProperties`                  | `<path>: Unsupported keyword <key>`                                            |
+| A discriminated union branch without a component schema `$ref`                                  | `<path>: Discriminator branch requires a component schema reference`           |
+| An implicit branch name claimed by an explicit mapping to another branch                        | `<path>: Discriminator branch has no unique value`                             |
+| A mapped component that is neither an object nor an `allOf` schema                              | `<path>: Unsupported discriminator target`                                     |
 | `$ref` not pointing to `#/components/schemas/…`                                                 | `<path>: Unsupported schema reference <ref>`                                   |
 | Non-annotation keywords next to `$ref`                                                          | `<path>: Zod does not preserve <key> alongside $ref`                           |
 | Constraint keywords without `type` (except `enum`, `const`, `allOf`, `anyOf`, `oneOf`)          | `<path>: Constraints without a type are not supported by Zod`                  |
@@ -311,6 +338,7 @@ Generation fails with `ZodGenerationError` when it finds any of the following:
 | Any operation without `operationId`; duplicate ids; ids `__proto__`/`constructor`/`prototype`   | `Missing operationId` / `Duplicate operationId` / `Unsupported operationId`    |
 | Component name that is not a valid JS identifier, is a reserved word, or is `z` / `definitions` | `<name>: Cannot emit this name as a schema export`                             |
 | Component name equal to some `<operationId>RequestBody`                                         | `<name>: Duplicate schema export`                                              |
+| With `camelCase: true`, two property names that become the same camelCase name                  | `<path>: <a> and <b> both become <camelName>`                                  |
 | Zod cannot convert the schema                                                                   | `<ExportName>: <Zod error message>`                                            |
 
 Not generated:
@@ -321,24 +349,24 @@ Not generated:
 
 ## Troubleshooting
 
-- **`Cannot find module './types'` or type errors in the generated file.** The Zod module imports `./types`. Generate it with the CLI, which writes `types.ts`, or run `openapi generate typescript` into the same directory.
-- **`types.ts` looks stale or was generated with other flags.** The CLI keeps an existing `types.ts` whose stamp matches the input. Pass `--force` to rewrite it with default flags.
-- **`Unsupported keyword discriminator`.** Remove `discriminator` from the schema, or express the union with `oneOf`/`anyOf` and `const` only. Zod generation does not accept the keyword.
+- **`Cannot find module './types'` or type errors in the generated file.** The Zod module imports `./types`. Generate it with the CLI, which writes `types.ts` next to `zod-schema.ts` on every run.
+- **`Unsupported keyword discriminator`.** Upgrade from 0.0.1; discriminators on `oneOf`/`anyOf` and `allOf` inheritance are supported. A discriminated union branch must be a component schema `$ref`.
 - **`Missing operationId`.** Every operation needs an `operationId`, even operations with no request body.
-- **Runtime errors from `z.fromJSONSchema`/`z.compile`.** Check that your app resolves `zod@4.6.5`.
+- **Wrong Zod version.** Install `zod@4.6.7` in the package that owns the generated file. The error reports the version and path found from the output location.
 
 ## Key facts (for AI agents)
 
 - Purpose: OpenAPI 3.1 document → one TypeScript module of Zod 4 validators. 3.0 input is upgraded only when run through the CLI or `generate()`.
-- Run: `openapi generate zod <input> -o <dir>/<file>.ts [--force]` (CLI from `@shipworthy/openapi-cli`, runs on Node.js `>=22.19.0` or Bun). It also writes `<dir>/types.ts` when that file is missing or stale.
+- Run: `openapi generate zod -i <input> -o <dir> [--camel-case] [TypeScript flags]` (CLI from `@shipworthy/openapi-cli`, runs on Node.js `>=22.19.0` or Bun). It writes `<dir>/zod-schema.ts` and `<dir>/types.ts` on every run. Combine it with other plugins in one run, e.g. `openapi generate zod tanstack-query -i <input> -o <dir>`.
 - Exports from generated file: `<ComponentName>` for each `components.schemas` entry, and `<operationId>RequestBody` for each operation with a single `application/json` request body. Nothing for responses or parameters.
 - Each export is `z.compile(z.fromJSONSchema(...)) as z.ZodType<T>`, where `T` comes from `./types`. Use `.parse` / `.safeParse`.
 - `default` values are stripped. Parsing never injects defaults.
-- Runtime dependency of generated code: `zod@4.6.5` (pinned).
+- Runtime dependency of generated code: `zod@4.6.7` (pinned).
 - Package exports: `zod` (generator plugin), `zodSources`, `operationRoutes`, `ZodGenerationError`, and the types `ZodSource`, `OperationRoute`, `HttpMethod`. All functions return Effect 4 values.
-- Generation is all-or-nothing for the Zod file. Unsupported keywords fail with a JSON-pointer message, but the CLI may already have written `types.ts`.
+- Library option `camelCase: true` (on `zod.generate` and `zodSources`) renames snake_case properties so validators match a camelCase `types.ts`. The CLI flag `--camel-case` sets it and generates the matching `types.ts`. Enum/const values and `patternProperties` keys keep API spelling. Name collisions fail generation.
+- Generation is all-or-nothing. Unsupported keywords fail with a JSON-pointer message, and the CLI then writes neither `zod-schema.ts` nor `types.ts`.
 - Every operation needs a unique `operationId`. Component names must be valid JS identifiers.
-- The package ships compiled ESM JavaScript with `.d.ts` declarations (no CommonJS build). Peer dependency `zod@4.6.5`.
+- The package ships compiled ESM JavaScript with `.d.ts` declarations (no CommonJS build). Peer dependency `zod@4.6.7`.
 
 ## License
 

package/dist/errors.d.ts

@@ -2,7 +2,9 @@ import { Schema } from "effect";
 declare const ZodGenerationError_base: Schema.Class<ZodGenerationError, Schema.TaggedStruct<"ZodGenerationError", {
     readonly message: Schema.String;
     readonly cause: Schema.optionalKey<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+    readonly brand: unique symbol;
+}>;
 export declare class ZodGenerationError extends ZodGenerationError_base {
 }
 export {};

package/dist/generate.d.ts

@@ -18,5 +18,11 @@ export type ZodSource = string;
  *
  * `routes` selects which operations can produce a request-body validator.
  * `operationRoutes` builds that table from the document.
+ * Pass `outputPath` to validate with the Zod installation visible to the generated file.
+ * Pass `camelCase: true` to rename snake_case properties to camelCase, matching `types.ts`
+ * generated with `camelCase`. Two wire names that become the same name fail generation.
  */
-export declare const zodSources: (document: ParsedService, routes: Record<string, OperationRoute>) => Effect.Effect<string, ZodGenerationError, never>;
+export declare const zodSources: (document: ParsedService, routes: Record<string, OperationRoute>, options?: {
+    readonly outputPath?: string;
+    readonly camelCase?: boolean;
+} | undefined) => Effect.Effect<string, ZodGenerationError, never>;

package/dist/generate.js

@@ -1,9 +1,9 @@
-import { ParsedSchema } from "@shipworthy/openapi-transformer";
-import { Array, Effect, Option, Order, Predicate, Record, Schema, pipe } from "effect";
-import * as z from "zod";
+import { camelCaseSchema, ParsedDiscriminator, ParsedSchema, propertyName, schemaPropertyCollision, } from "@shipworthy/openapi-transformer";
+import { Array, Effect, Formatter, Option, Order, Predicate, Record, Result, Schema, String, Struct, pipe, } from "effect";
 import { ZodGenerationError } from "./errors.js";
 import { assertExportName } from "./names.js";
 import { resolveDocumentRef } from "./refs.js";
+import { loadZod } from "./zod.js";
 const schemaMaps = ["properties", "patternProperties"];
 const compositions = ["allOf", "anyOf", "oneOf"];
 const schemaFields = ["items", "additionalProperties", "propertyNames", "contains"];
@@ -20,7 +20,7 @@ const annotations = new Set([
     "externalDocs",
     "xml",
 ]);
-const untypedKeywords = new Set(["enum", "const", "allOf", "anyOf", "oneOf"]);
+const untypedKeywords = new Set(["enum", "const", "allOf", "anyOf", "oneOf", "discriminator"]);
 const keywords = new Set([
     "$ref",
     "type",
@@ -32,6 +32,7 @@ const keywords = new Set([
     "not",
     "required",
     "dependentRequired",
+    "discriminator",
     "minProperties",
     "maxProperties",
     "prefixItems",
@@ -50,8 +51,145 @@ const keywords = new Set([
     "exclusiveMaximum",
     "multipleOf",
 ]);
+const discriminatorOf = Effect.fnUntraced(function* (value, path) {
+    if (value === undefined)
+        return undefined;
+    return yield* Schema.decodeUnknownEffect(ParsedDiscriminator)(value).pipe(Effect.mapError(() => new ZodGenerationError({ message: `${path}: Unsupported discriminator` })));
+});
+function schemaName(ref) {
+    const prefix = "#/components/schemas/";
+    if (!pipe(ref, String.startsWith(prefix)))
+        return undefined;
+    const token = pipe(ref, String.slice(prefix.length));
+    if (!token || pipe(token, String.includes("/")))
+        return undefined;
+    return pipe(token, String.replaceAll("~1", "/"), String.replaceAll("~0", "~"));
+}
+function componentRef(name) {
+    return `#/components/schemas/${pipe(name, String.replaceAll("~", "~0"), String.replaceAll("/", "~1"))}`;
+}
+function discriminatorValues(discriminator, ref) {
+    const name = schemaName(ref);
+    if (name === undefined)
+        return [];
+    const mapped = pipe(Record.toEntries(discriminator.mapping ?? {}), Array.filter(([, target]) => target === ref || target === name), Array.map(([value]) => value));
+    if (mapped.length > 0)
+        return mapped;
+    return Record.has(discriminator.mapping ?? {}, name) ? [] : [name];
+}
+const branchValues = Effect.fnUntraced(function* (discriminator, ref, path) {
+    const values = discriminatorValues(discriminator, ref);
+    if (values.length === 0)
+        return yield* new ZodGenerationError({
+            message: `${path}: Discriminator branch has no unique value`,
+        });
+    return values;
+});
+const discriminatorDiagnostics = Effect.fnUntraced(function* (schema, path) {
+    if (typeof schema === "boolean")
+        return;
+    const discriminator = yield* discriminatorOf(schema.discriminator, path);
+    if (!discriminator)
+        return;
+    const key = schema.oneOf !== undefined && schema.anyOf === undefined
+        ? "oneOf"
+        : schema.anyOf !== undefined && schema.oneOf === undefined
+            ? "anyOf"
+            : undefined;
+    if (!key)
+        return;
+    const parts = yield* schemaList(schema[key], path, key);
+    const branchIndices = yield* Effect.forEach(parts, Effect.fnUntraced(function* (part, index) {
+        const ref = Predicate.isObject(part) ? part.$ref : undefined;
+        const branchPath = `${path}/${key}/${index}`;
+        if (!Predicate.isString(ref) || schemaName(ref) === undefined)
+            return yield* new ZodGenerationError({
+                message: `${branchPath}: Discriminator branch requires a component schema reference`,
+            });
+        const values = yield* branchValues(discriminator, ref, branchPath);
+        return Array.map(values, (value) => [value, index]);
+    }));
+    return {
+        propertyName: discriminator.propertyName,
+        branchCount: parts.length,
+        branchIndices: Array.flatten(branchIndices),
+    };
+});
+const addDiscriminatorConstraint = Effect.fnUntraced(function* (constraints, ref, propertyName, values) {
+    yield* Effect.sync(() => {
+        const existing = constraints.get(ref);
+        if (existing === null)
+            return;
+        if (existing && existing.propertyName !== propertyName) {
+            constraints.set(ref, null);
+            return;
+        }
+        constraints.set(ref, {
+            propertyName,
+            values: existing ? Array.dedupe([...existing.values, ...values]) : values,
+        });
+    });
+});
+function discriminatorValue(values) {
+    return { type: "string", enum: [...values] };
+}
+function discriminatorConstraint(propertyName, values) {
+    return {
+        type: "object",
+        required: [propertyName],
+        properties: { [propertyName]: discriminatorValue(values) },
+    };
+}
+const discriminatorBranch = Effect.fnUntraced(function* (part, discriminator, path) {
+    const ref = Predicate.isObject(part) ? part.$ref : undefined;
+    if (!Predicate.isString(ref) || schemaName(ref) === undefined)
+        return yield* new ZodGenerationError({
+            message: `${path}: Discriminator branch requires a component schema reference`,
+        });
+    const values = yield* branchValues(discriminator, ref, path);
+    return {
+        allOf: [part, discriminatorConstraint(discriminator.propertyName, values)],
+    };
+});
+const constrainComponent = Effect.fnUntraced(function* (schema, constraint, path) {
+    if (!constraint)
+        return schema;
+    if (typeof schema === "boolean")
+        return yield* new ZodGenerationError({ message: `${path}: Unsupported discriminator target` });
+    if (schema.allOf) {
+        return {
+            ...schema,
+            allOf: [
+                ...(yield* schemaList(schema.allOf, path, "allOf")),
+                discriminatorConstraint(constraint.propertyName, constraint.values),
+            ],
+        };
+    }
+    if (schema.type !== "object")
+        return yield* new ZodGenerationError({ message: `${path}: Unsupported discriminator target` });
+    const properties = schema.properties
+        ? yield* schemaMap(schema.properties, path, "properties")
+        : {};
+    if (properties[constraint.propertyName] !== undefined) {
+        return {
+            ...schema,
+            allOf: [discriminatorConstraint(constraint.propertyName, constraint.values)],
+        };
+    }
+    const required = schema.required
+        ? yield* Schema.decodeUnknownEffect(Schema.Array(Schema.String))(schema.required).pipe(Effect.mapError(() => new ZodGenerationError({ message: `${path}: Unsupported required constraint` })))
+        : [];
+    return {
+        ...schema,
+        required: Array.dedupe([...required, constraint.propertyName]),
+        properties: {
+            ...properties,
+            [constraint.propertyName]: discriminatorValue(constraint.values),
+        },
+    };
+});
 function isAnnotation(key) {
-    return annotations.has(key) || key.startsWith("x-");
+    return annotations.has(key) || pipe(key, String.startsWith("x-"));
 }
 const encodeJson = Effect.fnUntraced(function* (value) {
     return yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))(value).pipe(Effect.mapError((cause) => new ZodGenerationError({ message: cause.message, cause })));
@@ -65,6 +203,133 @@ const schemaMap = Effect.fnUntraced(function* (value, path, keyword) {
 const schemaList = Effect.fnUntraced(function* (value, path, keyword) {
     return yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Unknown))(value).pipe(Effect.mapError(() => new ZodGenerationError({ message: `${path}: Unsupported ${keyword}` })), Effect.flatMap((values) => Effect.forEach(values, (part, index) => asSchema(part, `${path}/${keyword}/${index}`))));
 });
+const scanDiscriminatorSchema = Effect.fnUntraced(function* (schema, path, constraints, strict = true) {
+    if (typeof schema === "boolean")
+        return;
+    const discriminator = strict
+        ? yield* discriminatorOf(schema.discriminator, path)
+        : yield* discriminatorOf(schema.discriminator, path).pipe(Effect.orElseSucceed(() => undefined));
+    if (discriminator) {
+        yield* Effect.forEach(["oneOf", "anyOf"], Effect.fnUntraced(function* (key) {
+            if (!schema[key])
+                return;
+            const parts = strict
+                ? yield* schemaList(schema[key], path, key)
+                : yield* schemaList(schema[key], path, key).pipe(Effect.orElseSucceed(() => []));
+            yield* Effect.forEach(parts, Effect.fnUntraced(function* (part, index) {
+                const ref = Predicate.isObject(part) ? part.$ref : undefined;
+                const branchPath = `${path}/${key}/${index}`;
+                if (!Predicate.isString(ref) || schemaName(ref) === undefined) {
+                    if (strict)
+                        return yield* new ZodGenerationError({
+                            message: `${branchPath}: Discriminator branch requires a component schema reference`,
+                        });
+                    return;
+                }
+                const values = strict
+                    ? yield* branchValues(discriminator, ref, branchPath)
+                    : discriminatorValues(discriminator, ref);
+                if (values.length === 0)
+                    return;
+                yield* addDiscriminatorConstraint(constraints, ref, discriminator.propertyName, values);
+            }), { discard: true });
+        }), { discard: true });
+        if (schema.oneOf || schema.anyOf) {
+            yield* Effect.forEach(Record.values(discriminator.mapping ?? {}), Effect.fnUntraced(function* (target) {
+                const ref = pipe(target, String.startsWith("#")) ? target : componentRef(target);
+                if (schemaName(ref) === undefined)
+                    return;
+                yield* addDiscriminatorConstraint(constraints, ref, discriminator.propertyName, discriminatorValues(discriminator, ref));
+            }), { discard: true });
+        }
+    }
+    yield* Effect.forEach(schemaMaps, Effect.fnUntraced(function* (key) {
+        if (!schema[key])
+            return;
+        const values = strict
+            ? yield* schemaMap(schema[key], path, key)
+            : yield* schemaMap(schema[key], path, key).pipe(Effect.orElseSucceed(() => ({})));
+        yield* Effect.forEach(Record.toEntries(values), ([name, part]) => scanDiscriminatorSchema(part, `${path}/${key}/${name}`, constraints, strict), { discard: true });
+    }), { discard: true });
+    yield* Effect.forEach([...compositions, "prefixItems"], Effect.fnUntraced(function* (key) {
+        if (!schema[key])
+            return;
+        const parts = strict
+            ? yield* schemaList(schema[key], path, key)
+            : yield* schemaList(schema[key], path, key).pipe(Effect.orElseSucceed(() => []));
+        yield* Effect.forEach(parts, (part, index) => scanDiscriminatorSchema(part, `${path}/${key}/${index}`, constraints, strict), { discard: true });
+    }), { discard: true });
+    yield* Effect.forEach([...schemaFields, "not"], Effect.fnUntraced(function* (key) {
+        if (schema[key] === undefined)
+            return;
+        if (Array.isArray(schema[key]))
+            return;
+        const part = strict
+            ? yield* asSchema(schema[key], `${path}/${key}`)
+            : yield* asSchema(schema[key], `${path}/${key}`).pipe(Effect.orElseSucceed(() => undefined));
+        if (part === undefined)
+            return;
+        yield* scanDiscriminatorSchema(part, `${path}/${key}`, constraints, strict);
+    }), { discard: true });
+});
+const scanContentSchemas = Effect.fnUntraced(function* (contents, path, constraints, strict = false) {
+    yield* Effect.forEach(contents, (content) => content.schema === undefined
+        ? Effect.void
+        : scanDiscriminatorSchema(content.schema, `${path}/${content.mediaType}`, constraints, strict), { discard: true });
+});
+const scanHeaderSchemas = Effect.fnUntraced(function* (header, path, constraints) {
+    if (header.schema !== undefined)
+        yield* scanDiscriminatorSchema(header.schema, `${path}/schema`, constraints, false);
+    yield* scanContentSchemas(header.contents, `${path}/content`, constraints);
+});
+const scanDiscriminatorConstraints = Effect.fnUntraced(function* (model) {
+    const constraints = new Map();
+    yield* Effect.forEach(Record.toEntries(model.components.schemas), ([name, schema]) => scanDiscriminatorSchema(schema, componentRef(name), constraints), { discard: true });
+    yield* Effect.forEach(model.operations, Effect.fnUntraced(function* (operation) {
+        const location = `${operation.method} ${operation.path}`;
+        yield* Effect.forEach([
+            ...operation.request.path,
+            ...operation.request.query,
+            ...operation.request.headers,
+            ...operation.request.cookie,
+        ], (parameter) => scanHeaderSchemas(parameter, `${location}/parameters/${parameter.name}`, constraints), { discard: true });
+        if (operation.request.body)
+            yield* scanContentSchemas(operation.request.body.contents, `${location}/requestBody`, constraints, true);
+        yield* Effect.forEach(operation.responses, Effect.fnUntraced(function* (response) {
+            const responsePath = `${location}/responses/${response.code}`;
+            yield* scanContentSchemas(response.contents, `${responsePath}/content`, constraints);
+            yield* Effect.forEach(response.headers, (header) => scanHeaderSchemas(header, `${responsePath}/headers/${header.name}`, constraints), { discard: true });
+        }), { discard: true });
+    }), { discard: true });
+    yield* Effect.forEach(Record.toEntries(model.components.requestBodies), ([name, body]) => scanContentSchemas(body.contents, `#/components/requestBodies/${name}`, constraints), { discard: true });
+    yield* Effect.forEach(Record.toEntries(model.components.responses), Effect.fnUntraced(function* ([name, response]) {
+        const responsePath = `#/components/responses/${name}`;
+        yield* scanContentSchemas(response.contents, `${responsePath}/content`, constraints);
+        yield* Effect.forEach(response.headers, (header) => scanHeaderSchemas(header, `${responsePath}/headers/${header.name}`, constraints), { discard: true });
+    }), { discard: true });
+    yield* Effect.forEach(Record.toEntries(model.components.parameters), ([name, parameter]) => scanHeaderSchemas(parameter, `#/components/parameters/${name}`, constraints), { discard: true });
+    yield* Effect.forEach(Record.toEntries(model.components.headers), ([name, header]) => scanHeaderSchemas(header, `#/components/headers/${name}`, constraints), { discard: true });
+    yield* Effect.forEach(Record.toEntries(model.components.schemas), Effect.fnUntraced(function* ([name, schema]) {
+        if (typeof schema === "boolean" || !schema.allOf)
+            return;
+        const path = componentRef(name);
+        const parts = yield* schemaList(schema.allOf, path, "allOf");
+        yield* Effect.forEach(parts, Effect.fnUntraced(function* (part) {
+            const ref = Predicate.isObject(part) ? part.$ref : undefined;
+            if (!Predicate.isString(ref) || schemaName(ref) === undefined)
+                return;
+            const parent = yield* resolveDocumentRef(model, ref).pipe(Effect.flatMap((value) => asSchema(value, ref)));
+            const discriminator = typeof parent === "boolean"
+                ? undefined
+                : yield* discriminatorOf(parent.discriminator, ref);
+            if (!discriminator)
+                return;
+            const values = yield* branchValues(discriminator, path, path);
+            yield* addDiscriminatorConstraint(constraints, path, discriminator.propertyName, values);
+        }), { discard: true });
+    }), { discard: true });
+    return constraints;
+});
 function definitionSchema(schema) {
     if (schema === true)
         return {};
@@ -80,25 +345,25 @@ function isSingleRequiredKey(part) {
         Predicate.isString(part.required[0]));
 }
 function indent(value, spaces) {
-    const pad = " ".repeat(spaces);
-    return pipe(value.split("\n"), Array.map((line) => (line.length === 0 ? line : pad + line)), Array.join("\n"));
+    const pad = pipe(" ", String.repeat(spaces));
+    return pipe(value, String.split("\n"), Array.map((line) => (line.length === 0 ? line : pad + line)), Array.join("\n"));
 }
 function schemaLiteral(schema, names, expression) {
     if (names.length === 0)
-        return expression ?? JSON.stringify(schema, null, 2);
-    const defs = indent(pipe(names, Array.map((name) => `${JSON.stringify(name)}: definitions.${name}`), Array.join(",\n")), 4);
+        return expression ?? Formatter.formatJson(schema, { space: 2 });
+    const defs = indent(pipe(names, Array.map((name) => `${Formatter.formatJson(name)}: definitions.${name}`), Array.join(",\n")), 4);
     if (expression)
         return `{\n  ...${expression},\n  $defs: {\n${defs}\n  },\n}`;
-    const json = JSON.stringify(schema, null, 2);
-    if (!json.startsWith("{\n"))
+    const json = Formatter.formatJson(schema, { space: 2 });
+    if (!pipe(json, String.startsWith("{\n")))
         return `{\n  $defs: {\n${defs}\n  },\n}`;
-    return `{\n${json.slice(2, -2)},\n  $defs: {\n${defs}\n  },\n}`;
+    return `{\n${pipe(json, String.slice(2, -2))},\n  $defs: {\n${defs}\n  },\n}`;
 }
 const definitionName = Effect.fnUntraced(function* (ref) {
     const marker = "#/$defs/";
-    if (!ref.startsWith(marker))
+    if (!pipe(ref, String.startsWith(marker)))
         return yield* new ZodGenerationError({ message: `${ref}: Reference not found` });
-    return ref.slice(marker.length).replaceAll("~1", "/").replaceAll("~0", "~");
+    return pipe(ref, String.slice(marker.length), String.replaceAll("~1", "/"), String.replaceAll("~0", "~"));
 });
 const objectProperties = Effect.fnUntraced(function* (document, schema, path, seen) {
     if (typeof schema === "boolean")
@@ -131,12 +396,23 @@ const normalize = Effect.fnUntraced(function* (document, schema, path, inherited
         });
     const result = { ...schema };
     delete result.default;
+    delete result.discriminator;
+    const discriminator = yield* discriminatorOf(schema.discriminator, path);
+    if (discriminator) {
+        yield* Effect.forEach(["oneOf", "anyOf"], Effect.fnUntraced(function* (key) {
+            if (!result[key])
+                return;
+            const parts = yield* schemaList(result[key], path, key);
+            result[key] = yield* Effect.forEach(parts, (part, index) => discriminatorBranch(part, discriminator, `${path}/${key}/${index}`));
+        }), { discard: true });
+    }
     const properties = {
         ...inherited,
         ...(yield* objectProperties(document, schema, path, new Set())),
     };
     if (schema.$ref) {
-        if (!Predicate.isString(schema.$ref) || !schema.$ref.startsWith("#/components/schemas/")) {
+        if (!Predicate.isString(schema.$ref) ||
+            !pipe(schema.$ref, String.startsWith("#/components/schemas/"))) {
             const ref = Predicate.isString(schema.$ref) ? schema.$ref : yield* encodeJson(schema.$ref);
             return yield* new ZodGenerationError({
                 message: `${path}: Unsupported schema reference ${ref}`,
@@ -148,7 +424,7 @@ const normalize = Effect.fnUntraced(function* (document, schema, path, inherited
             return yield* new ZodGenerationError({
                 message: `${path}: Zod does not preserve ${sibling.value} alongside $ref`,
             });
-        result.$ref = `#/$defs/${schema.$ref.slice("#/components/schemas/".length)}`;
+        result.$ref = `#/$defs/${pipe(schema.$ref, String.slice("#/components/schemas/".length))}`;
         return result;
     }
     // In an object intersection, not(anyOf(required(single key))) forbids those keys.
@@ -275,17 +551,50 @@ const visit = Effect.fnUntraced(function* (schema, needed, definitions) {
         }
     }), { discard: true });
 });
-const compileExport = Effect.fnUntraced(function* (name, root) {
+const compileExport = Effect.fnUntraced(function* (z, name, root) {
     return yield* Effect.try({
         try: () => {
             z.compile(z.fromJSONSchema(root));
         },
         catch: (cause) => new ZodGenerationError({
-            message: `${name}: ${cause instanceof Error ? cause.message : String(cause)}`,
+            message: `${name}: ${cause instanceof Error ? cause.message : globalThis.String(cause)}`,
             cause,
         }),
     });
 });
+const discriminatorIssueHelper = `function __openapiDiscriminatorIssues(
+  schema: z.ZodType,
+  propertyName: string,
+  branchCount: number,
+  branchIndices: ReadonlyMap<string, number>,
+) {
+  return z.unknown().transform((input, context) => {
+    const parsed = schema.safeParse(input);
+    if (parsed.success) return parsed.data;
+
+    const tag: unknown =
+      typeof input === "object" && input !== null ? Reflect.get(input, propertyName) : undefined;
+    const index = typeof tag === "string" ? branchIndices.get(tag) : undefined;
+
+    for (const issue of parsed.error.issues) {
+      const selected =
+        index !== undefined &&
+        issue.code === "invalid_union" &&
+        issue.path.length === 0 &&
+        issue.errors.length === branchCount
+          ? issue.errors[index]
+          : undefined;
+
+      if (selected && selected.length > 0) {
+        for (const detail of selected) context.addIssue({ ...detail });
+      } else {
+        context.addIssue({ ...issue });
+      }
+    }
+
+    return z.NEVER;
+  });
+}`;
 function renderSource(entries, definitions, exports) {
     if (exports.length === 0)
         return "";
@@ -297,21 +606,31 @@ function renderSource(entries, definitions, exports) {
         ], "\n"),
     ];
     if (definitions.size > 0) {
-        const keys = pipe(Array.fromIterable(definitions.keys()), Array.map((name) => JSON.stringify(name)), Array.join(" | "));
-        const values = pipe(Array.fromIterable(definitions), Array.map(([name, schema]) => `${JSON.stringify(name)}: ${JSON.stringify(schema, null, 2)}`), Array.join(",\n"));
+        const keys = pipe(Array.fromIterable(definitions.keys()), Array.map((name) => Formatter.formatJson(name)), Array.join(" | "));
+        const values = pipe(Array.fromIterable(definitions), Array.map(([name, schema]) => `${Formatter.formatJson(name)}: ${Formatter.formatJson(schema, { space: 2 })}`), Array.join(",\n"));
         blocks.push(`const definitions: Record<${keys}, z.core.JSONSchema.JSONSchema> = {\n${indent(values, 2)},\n};`);
     }
+    if (Array.some(entries, (entry) => entry.discriminatorDiagnostics !== undefined))
+        blocks.push(discriminatorIssueHelper);
     return `${Array.join([...blocks, ...exports], "\n\n")}\n`;
 }
-const source = Effect.fnUntraced(function* (entries, definitions) {
+const source = Effect.fnUntraced(function* (entries, definitions, outputPath) {
     const seen = new Set();
+    const hasDiscriminatorDiagnostics = Array.some(entries, (entry) => entry.discriminatorDiagnostics !== undefined);
     yield* Effect.forEach(entries, Effect.fnUntraced(function* ({ name }) {
-        yield* assertExportName(name, ["z", "definitions"]);
+        yield* assertExportName(name, [
+            "z",
+            "definitions",
+            ...(hasDiscriminatorDiagnostics ? ["__openapiDiscriminatorIssues"] : []),
+        ]);
         if (seen.has(name))
             return yield* new ZodGenerationError({ message: `${name}: Duplicate schema export` });
         seen.add(name);
     }), { discard: true });
-    return yield* Effect.forEach(entries, Effect.fnUntraced(function* ({ name, schema, type, expression }) {
+    if (entries.length === 0)
+        return "";
+    const z = yield* loadZod(outputPath);
+    return yield* Effect.forEach(entries, Effect.fnUntraced(function* ({ name, schema, type, expression, discriminatorDiagnostics }) {
         const needed = new Set();
         yield* visit(schema, needed, definitions);
         const names = Array.sort(needed, Order.String);
@@ -326,30 +645,48 @@ const source = Effect.fnUntraced(function* (entries, definitions) {
         const root = typeof schema === "boolean"
             ? schema
             : { ...schema, ...(names.length > 0 ? { $defs: defs } : {}) };
-        yield* compileExport(name, root);
+        yield* compileExport(z, name, root);
         const argument = schemaLiteral(schema, names, expression);
-        return `export const ${name} = z.compile(z.fromJSONSchema(${argument})) as z.ZodType<${type}>;`;
+        const compiled = `z.compile(z.fromJSONSchema(${argument}))`;
+        let validator = compiled;
+        if (discriminatorDiagnostics) {
+            const { propertyName, branchIndices } = yield* Effect.all({
+                propertyName: encodeJson(discriminatorDiagnostics.propertyName),
+                branchIndices: encodeJson(discriminatorDiagnostics.branchIndices),
+            });
+            validator = `__openapiDiscriminatorIssues(${compiled}, ${propertyName}, ${discriminatorDiagnostics.branchCount}, new Map<string, number>(${branchIndices}))`;
+        }
+        return `export const ${name} = ${validator} as z.ZodType<${type}>;`;
     })).pipe(Effect.map((exports) => renderSource(entries, definitions, exports)));
 });
-const compile = Effect.fnUntraced(function* (model, routes) {
-    if (!model.openapi.startsWith("3.1."))
+const compile = Effect.fnUntraced(function* (model, routes, outputPath) {
+    if (!pipe(model.openapi, String.startsWith("3.1.")))
         return yield* new ZodGenerationError({ message: "Zod generation requires OpenAPI 3.1" });
     if (model.jsonSchemaDialect || Record.keys(model.$defs).length > 0) {
         return yield* new ZodGenerationError({
             message: "Zod generation does not support custom dialects or top-level $defs",
         });
     }
-    const definitions = yield* Effect.forEach(Record.toEntries(model.components.schemas), ([name, schema]) => normalize(model, schema, `#/components/schemas/${name}`).pipe(Effect.map((normalized) => [name, normalized]))).pipe(Effect.map((entries) => new Map(entries)));
-    const components = Array.map(Array.fromIterable(definitions), ([name, schema]) => ({
+    const constraints = yield* scanDiscriminatorConstraints(model);
+    const prepared = yield* Effect.forEach(Record.toEntries(model.components.schemas), Effect.fnUntraced(function* ([name, schema]) {
+        const path = componentRef(name);
+        const constrained = yield* constrainComponent(schema, constraints.get(path), path);
+        const normalized = yield* normalize(model, constrained, path);
+        const diagnostics = yield* discriminatorDiagnostics(schema, path);
+        return [name, normalized, diagnostics];
+    }));
+    const definitions = new Map(Array.map(prepared, ([name, schema]) => [name, schema]));
+    const components = Array.map(prepared, ([name, schema, diagnostics]) => ({
         name,
         schema,
         types: "components",
-        type: `components["schemas"][${JSON.stringify(name)}]`,
+        type: `components["schemas"][${Formatter.formatJson(name)}]`,
         expression: `definitions.${name}`,
+        discriminatorDiagnostics: diagnostics,
     }));
     const operations = yield* Effect.forEach(model.operations, Effect.fnUntraced(function* (operation) {
         const id = operation.operationId;
-        if (!id || !Object.hasOwn(routes, id))
+        if (!id || !Record.has(routes, id))
             return;
         const location = `${operation.method} ${operation.path}`;
         const body = operation.request.body;
@@ -371,10 +708,92 @@ const compile = Effect.fnUntraced(function* (model, routes) {
             types: "operations",
             type: `NonNullable<operations[${idLiteral}]["requestBody"]>["content"]["application/json"]`,
             schema: yield* normalize(model, content.value.schema, location),
+            discriminatorDiagnostics: yield* discriminatorDiagnostics(content.value.schema, location),
         };
     })).pipe(Effect.map(Array.filter(Predicate.isNotUndefined)));
-    return yield* source([...components, ...operations], definitions);
+    return yield* source([...components, ...operations], definitions, outputPath);
 });
+/** The JSON request-body schema an operation exports as `<operationId>RequestBody`, if any. */
+function exportedRequestBody(operation, routes) {
+    const id = operation.operationId;
+    if (!id || !Record.has(routes, id) || !operation.request.body)
+        return undefined;
+    const contents = operation.request.body.contents;
+    const content = contents.length === 1 ? contents[0] : undefined;
+    return content?.mediaType === "application/json" ? content.schema : undefined;
+}
+/** Fail when two wire names in one exported schema become the same camelCase name. */
+const assertNoCamelCaseCollisions = Effect.fnUntraced(function* (model, routes) {
+    const resolve = (ref) => {
+        const name = schemaName(ref);
+        return name !== undefined && Record.has(model.components.schemas, name)
+            ? model.components.schemas[name]
+            : undefined;
+    };
+    const roots = [
+        ...Array.map(Record.toEntries(model.components.schemas), ([name, schema]) => [componentRef(name), schema]),
+        ...Array.filterMap(model.operations, (operation) => {
+            const schema = exportedRequestBody(operation, routes);
+            return schema === undefined
+                ? Result.failVoid
+                : Result.succeed([`${operation.method} ${operation.path}`, schema]);
+        }),
+    ];
+    yield* Effect.forEach(roots, Effect.fnUntraced(function* ([path, schema]) {
+        const collision = schemaPropertyCollision(schema, resolve);
+        if (!collision)
+            return;
+        const [a, b] = collision;
+        return yield* new ZodGenerationError({
+            message: `${path}: ${a} and ${b} both become ${propertyName(a, true)}`,
+        });
+    }), { discard: true });
+});
+const withCamelCaseSchema = {
+    schema: (schema) => schema === undefined ? undefined : camelCaseSchema(schema),
+};
+const withCamelCaseContents = {
+    contents: Array.map((content) => Struct.evolve(content, withCamelCaseSchema)),
+};
+const withCamelCaseBody = {
+    contents: Array.map((content) => Struct.evolve(content, withCamelCaseSchema)),
+};
+function camelCaseHeader(header) {
+    return Struct.evolve(header, { ...withCamelCaseSchema, ...withCamelCaseContents });
+}
+function camelCaseParameter(parameter) {
+    return Struct.evolve(parameter, { ...withCamelCaseSchema, ...withCamelCaseContents });
+}
+const withCamelCaseResponse = { ...withCamelCaseBody, headers: Array.map(camelCaseHeader) };
+function camelCaseRequest(request) {
+    return Struct.evolve(request, {
+        path: Array.map(camelCaseParameter),
+        query: Array.map(camelCaseParameter),
+        headers: Array.map(camelCaseParameter),
+        cookie: Array.map(camelCaseParameter),
+        body: (body) => body === undefined ? undefined : Struct.evolve(body, withCamelCaseBody),
+    });
+}
+/**
+ * A copy of the model whose schemas use camelCase property names, so validators parse the
+ * shapes that camelCase `types.ts` declares. Every schema the generator reads is renamed,
+ * including the response and parameter schemas scanned for discriminator constraints.
+ */
+function camelCaseModel(model) {
+    return Struct.evolve(model, {
+        operations: Array.map((operation) => Struct.evolve(operation, {
+            request: camelCaseRequest,
+            responses: Array.map((response) => Struct.evolve(response, withCamelCaseResponse)),
+        })),
+        components: (components) => Struct.evolve(components, {
+            schemas: Record.map(camelCaseSchema),
+            responses: Record.map((response) => Struct.evolve(response, withCamelCaseResponse)),
+            parameters: Record.map(camelCaseParameter),
+            headers: Record.map(camelCaseHeader),
+            requestBodies: Record.map((body) => Struct.evolve(body, withCamelCaseBody)),
+        }),
+    });
+}
 /**
  * Turn an OpenAPI 3.1 document into Zod source.
  *
@@ -386,7 +805,13 @@ const compile = Effect.fnUntraced(function* (model, routes) {
  *
  * `routes` selects which operations can produce a request-body validator.
  * `operationRoutes` builds that table from the document.
+ * Pass `outputPath` to validate with the Zod installation visible to the generated file.
+ * Pass `camelCase: true` to rename snake_case properties to camelCase, matching `types.ts`
+ * generated with `camelCase`. Two wire names that become the same name fail generation.
  */
-export const zodSources = Effect.fn("zodSources")(function* (document, routes) {
-    return yield* compile(document, routes);
+export const zodSources = Effect.fn("zodSources")(function* (document, routes, options = {}) {
+    if (!options.camelCase)
+        return yield* compile(document, routes, options.outputPath);
+    yield* assertNoCamelCaseCollisions(document, routes);
+    return yield* compile(camelCaseModel(document), routes, options.outputPath);
 });

package/dist/index.js

@@ -1,4 +1,5 @@
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
+import { ZodGenerationError } from "./errors.js";
 import { zodSources } from "./generate.js";
 import { operationRoutes } from "./routes.js";
 export { ZodGenerationError } from "./errors.js";
@@ -6,7 +7,11 @@ export { zodSources } from "./generate.js";
 export { operationRoutes } from "./routes.js";
 export const zod = {
     id: "zod",
-    generate: Effect.fnUntraced(function* (model) {
-        return yield* operationRoutes(model).pipe(Effect.flatMap((routes) => zodSources(model, routes)));
+    generate: Effect.fnUntraced(function* (model, options) {
+        const parsed = yield* Schema.decodeEffect(Schema.Struct({
+            outputPath: Schema.optionalKey(Schema.String),
+            camelCase: Schema.optionalKey(Schema.Boolean),
+        }))(options).pipe(Effect.mapError(() => new ZodGenerationError({ message: "#: Invalid generator options" })));
+        return yield* operationRoutes(model).pipe(Effect.flatMap((routes) => zodSources(model, routes, parsed)));
     }),
 };

package/dist/routes.js

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Record } from "effect";
 import { ZodGenerationError } from "./errors.js";
 const methods = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
 const blockedOperationIds = new Set(["__proto__", "constructor", "prototype"]);
@@ -13,7 +13,7 @@ export const operationRoutes = Effect.fnUntraced(function* (model) {
         if (blockedOperationIds.has(id)) {
             return yield* new ZodGenerationError({ message: `Unsupported operationId: ${id}` });
         }
-        if (Object.hasOwn(routes, id)) {
+        if (Record.has(routes, id)) {
             return yield* new ZodGenerationError({ message: `Duplicate operationId: ${id}` });
         }
         routes[id] = [operation.method, operation.path];

package/dist/zod.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { ZodGenerationError } from "./errors.ts";
+/** Resolve the package visible to an ESM output file, then load its import entry. */
+export declare const loadZod: (outputPath?: string | undefined) => Effect.Effect<typeof import("zod"), ZodGenerationError, never>;

package/dist/zod.js

@@ -0,0 +1,93 @@
+import * as NodeModule from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Array, Effect, Option, Predicate, Schema, String, pipe } from "effect";
+import { ZodGenerationError } from "./errors.js";
+// The generated code targets the exact zod version in this package's peerDependencies.
+const GeneratorPackageJson = Schema.Struct({
+    peerDependencies: Schema.Struct({ zod: Schema.String }),
+});
+const requiredZodVersion = Effect.try({
+    try: () => NodeModule.createRequire(import.meta.url)("../package.json"),
+    catch: (cause) => new ZodGenerationError({ message: "#: Cannot read the zod generator package.json", cause }),
+}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(GeneratorPackageJson)), Effect.mapError((cause) => new ZodGenerationError({ message: "#: Cannot read the required zod version", cause })), Effect.map((manifest) => manifest.peerDependencies.zod));
+const PackageJson = Schema.Struct({
+    version: Schema.String,
+    exports: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),
+});
+function isMissingPackage(cause) {
+    return (Predicate.isObject(cause) &&
+        (cause.code === "ERR_MODULE_NOT_FOUND" || cause.code === "MODULE_NOT_FOUND"));
+}
+const findZodPackage = Effect.fnUntraced(function* (from) {
+    // Only an installed package can be imported by the generated module. Bun's
+    // resolver may otherwise auto-install a version from its global cache.
+    const resolver = yield* Effect.try({
+        try: () => NodeModule.createRequire(from),
+        catch: (cause) => new ZodGenerationError({ message: `#: Cannot resolve zod from ${from}`, cause }),
+    });
+    const start = yield* Effect.try({
+        try: () => new URL(".", from),
+        catch: (cause) => new ZodGenerationError({ message: `#: Cannot resolve zod from ${from}`, cause }),
+    });
+    const candidates = Array.unfold(Option.some(start), (directory) => Option.map(directory, (url) => {
+        const parent = new URL("..", url);
+        return [
+            new URL("node_modules/zod/package.json", url),
+            parent.href === url.href ? Option.none() : Option.some(parent),
+        ];
+    }));
+    const found = yield* Effect.forEach(candidates, (candidate) => Effect.try({
+        try: () => resolver.resolve(fileURLToPath(candidate)),
+        catch: (cause) => new ZodGenerationError({ message: `#: Cannot resolve zod from ${from}`, cause }),
+    }).pipe(Effect.catchIf((error) => isMissingPackage(error.cause), () => Effect.void)));
+    return Option.getOrUndefined(Array.findFirst(found, Predicate.isString));
+});
+/** Resolve the package visible to an ESM output file, then load its import entry. */
+export const loadZod = Effect.fnUntraced(function* (outputPath) {
+    const outputUrl = outputPath
+        ? yield* Effect.try({
+            try: () => pathToFileURL(outputPath).href,
+            catch: (cause) => new ZodGenerationError({ message: `#: Cannot resolve zod from ${outputPath}`, cause }),
+        })
+        : undefined;
+    const outputPackage = outputUrl ? yield* findZodPackage(outputUrl) : undefined;
+    const manifestPath = outputPackage ?? (yield* findZodPackage(import.meta.url));
+    if (!manifestPath)
+        return yield* new ZodGenerationError({
+            message: `#: Cannot resolve zod from ${outputPath ?? import.meta.url} or the generator`,
+        });
+    const rawManifest = yield* Effect.try({
+        try: () => NodeModule.createRequire(manifestPath)(manifestPath),
+        catch: (cause) => new ZodGenerationError({ message: `#: Cannot read zod package at ${manifestPath}`, cause }),
+    });
+    const manifest = yield* Schema.decodeUnknownEffect(PackageJson)(rawManifest).pipe(Effect.mapError((cause) => new ZodGenerationError({ message: `#: Cannot read zod version at ${manifestPath}`, cause })));
+    const requiredVersion = yield* requiredZodVersion;
+    if (manifest.version !== requiredVersion)
+        return yield* new ZodGenerationError({
+            message: `#: Found zod@${manifest.version} at ${manifestPath} (resolved from ${outputPackage ? outputPath : import.meta.url}); require zod@${requiredVersion}`,
+        });
+    const rootExport = manifest.exports?.["."];
+    const importEntry = Predicate.isObject(rootExport) ? rootExport.import : undefined;
+    if (!Predicate.isString(importEntry) || !pipe(importEntry, String.startsWith("./")))
+        return yield* new ZodGenerationError({
+            message: `#: Cannot resolve zod import entry at ${manifestPath}`,
+        });
+    const entry = yield* Effect.try({
+        try: () => fileURLToPath(new URL(importEntry, pathToFileURL(manifestPath))),
+        catch: (cause) => new ZodGenerationError({
+            message: `#: Cannot resolve zod import entry at ${manifestPath}`,
+            cause,
+        }),
+    });
+    const loaded = yield* Effect.try({
+        try: () => NodeModule.createRequire(manifestPath)(entry),
+        catch: (cause) => new ZodGenerationError({ message: `#: Cannot import zod at ${entry}`, cause }),
+    });
+    if (!Predicate.isObject(loaded) ||
+        !Predicate.isFunction(loaded.fromJSONSchema) ||
+        !Predicate.isFunction(loaded.compile))
+        return yield* new ZodGenerationError({
+            message: `#: zod@${manifest.version} at ${entry} does not expose fromJSONSchema and compile`,
+        });
+    return loaded;
+});

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@shipworthy/openapi-zod",
-  "version": "0.0.2",
+  "version": "1.0.0",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@shipworthy/openapi-generator": "0.0.2",
-    "@shipworthy/openapi-transformer": "0.0.2",
-    "@shipworthy/openapi-typescript": "0.0.2",
-    "effect": "^4.0.0"
+    "@shipworthy/openapi-generator": "1.0.0",
+    "@shipworthy/openapi-transformer": "1.0.0",
+    "@shipworthy/openapi-typescript": "1.0.0",
+    "effect": "4.1.4"
   },
   "peerDependencies": {
-    "zod": "4.6.5"
+    "zod": "4.6.7"
   },
   "description": "Generate Zod validators from OpenAPI 3.1 schemas.",
   "license": "MIT",
@@ -29,16 +29,16 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "test": "bun test test/generate.test.ts test/cli.test.ts",
+    "test": "bun test --timeout 30000 test/generate.test.ts test/cli.test.ts",
     "build": "rm -rf dist && tsc -p tsconfig.build.json"
   },
   "devDependencies": {
-    "@effect/platform-node": "^4.0.0",
+    "@effect/platform-node": "4.1.4",
     "@shipworthy/typescript-config": "0.0.1",
-    "@types/node": "^24.10.3",
+    "@types/node": "^26.6.6",
     "typescript": "^7.0.2",
-    "vitest": "5.0.3",
-    "zod": "4.6.5"
+    "vitest": "5.1.0",
+    "zod": "4.6.7"
   },
   "engines": {
     "node": ">=22.19.0"