@zipbul/baker 1.1.0 → 2.1.0

package/README.md

@@ -1,627 +1,315 @@
-<p align="center">
-  <h1 align="center">@zipbul/baker</h1>
-  <p align="center">
-    <strong>Decorator-based validate + transform with inline code generation</strong>
-  </p>
-  <p align="center">
-    Single <code>@Field()</code> decorator &middot; AOT-level performance &middot; zero reflect-metadata
-  </p>
-  <p align="center">
-    <a href="https://github.com/zipbul/baker/actions"><img src="https://github.com/zipbul/baker/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
-    <a href="https://www.npmjs.com/package/@zipbul/baker"><img src="https://img.shields.io/npm/v/@zipbul/baker.svg" alt="npm version"></a>
-    <a href="https://www.npmjs.com/package/@zipbul/baker"><img src="https://img.shields.io/npm/dm/@zipbul/baker.svg" alt="npm downloads"></a>
-    <a href="https://github.com/zipbul/baker/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@zipbul/baker.svg" alt="license"></a>
-  </p>
-</p>
-
-<p align="center">
-  <a href="./README.ko.md">한국어</a>
-</p>
-
----
+# @zipbul/baker
 
-## Why Baker?
-
-| | class-validator | Zod | TypeBox | **Baker** |
-|---|---|---|---|---|
-| Schema style | Decorators | Function chaining | JSON Schema builder | **Single `@Field()` decorator** |
-| Performance | Runtime interpreter | Runtime interpreter | JIT compile | **`new Function()` inline codegen** |
-| Transform built-in | Separate package | `.transform()` | N/A | **Unified** |
-| reflect-metadata | Required | N/A | N/A | **Not needed** |
-| class-validator migration | — | Full rewrite | Full rewrite | **Near drop-in** |
-
-Baker gives you a **single `@Field()` decorator** that combines validation, transformation, exposure control, and type hints. At first use, it auto-seals all DTOs by generating optimized functions via `new Function()` — delivering **AOT-equivalent performance without a compiler plugin**.
-
----
-
-## Features
-
-- **Single decorator** — `@Field()` replaces 30+ individual decorators
-- **80+ built-in rules** — `isString`, `min()`, `isEmail()` and more, composed as arguments
-- **Inline code generation** — auto-seal compiles validators at first `deserialize()`/`serialize()` call
-- **Unified validate + transform** — `deserialize()` and `serialize()` in one call (sync DTOs skip async overhead)
-- **Zero reflect-metadata** — no `reflect-metadata` import needed
-- **Circular reference detection** — automatic static analysis at seal time
-- **Group-based validation** — apply different rules per request with `groups`
-- **Custom rules** — `createRule()` for user-defined validators with codegen support
-- **JSON Schema output** — `toJsonSchema()` generates JSON Schema Draft 2020-12 from your DTOs
-- **Polymorphic discriminator** — `@Field({ discriminator })` for union types
-- **Whitelist mode** — reject undeclared fields with `configure({ forbidUnknown: true })`
-- **Class inheritance** — child DTOs inherit parent `@Field()` decorators automatically
-- **Async transforms** — transform functions can be async
-- **Map/Set support** — auto-convert between `Map`/`Set` and JSON-compatible types
-- **Per-field error messages** — `message` and `context` options on `@Field()` for custom errors
-
----
-
-## Installation
+The fastest decorator-based DTO validation library for TypeScript. Generates optimized validation code at class definition time (AOT), delivering **42ns per validation** — up to 163x faster than class-validator, 16x faster than Zod.
 
 ```bash
 bun add @zipbul/baker
 ```
 
-> **Requirements:** Bun >= 1.0, `experimentalDecorators: true` in tsconfig.json
+Zero `reflect-metadata`. Zero runtime overhead. 1,890 tests. 99%+ line coverage.
+
+## Quick Start
+
+```typescript
+import { deserialize, isBakerError, Field } from '@zipbul/baker';
+import { isString, isNumber, isEmail, min, minLength } from '@zipbul/baker/rules';
+
+class UserDto {
+  @Field(isString, minLength(2)) name!: string;
+  @Field(isNumber(), min(0)) age!: number;
+  @Field(isString, isEmail()) email!: string;
+}
+
+const result = await deserialize(UserDto, {
+  name: 'Alice', age: 30, email: 'alice@test.com',
+});
 
-```jsonc
-// tsconfig.json
-{
-  "compilerOptions": {
-    "experimentalDecorators": true
-  }
+if (isBakerError(result)) {
+  console.log(result.errors); // [{ path: 'email', code: 'isEmail' }]
+} else {
+  console.log(result.name);   // 'Alice' — typed as UserDto
 }
 ```
 
----
+## Why Baker?
 
-## Quick Start
+Baker generates optimized JavaScript validation functions **once** at class definition time, then executes them on every call — no interpretation, no schema traversal, no runtime compilation cost after the first seal.
 
-### 1. Define a DTO
+| Feature | baker | class-validator | Zod |
+|---|---|---|---|
+| Valid path (5 fields) | **42ns** | 6,852ns | 675ns |
+| Invalid path (5 fields) | **93ns** | 10,109ns | 7,948ns |
+| Approach | AOT code generation | Runtime interpretation | Schema method chain |
+| Decorators | `@Field` (unified) | 30+ individual | N/A |
+| `reflect-metadata` | Not needed | Required | N/A |
+| Sync DTO return | Direct value | Promise | Direct value |
 
-```typescript
-import { Field } from '@zipbul/baker';
-import { isString, isInt, isEmail, min, max } from '@zipbul/baker/rules';
+## Performance
 
-class CreateUserDto {
-  @Field(isString)
-  name!: string;
+Benchmarked against 6 libraries on a simple 5-field DTO (valid + invalid input):
 
-  @Field(isInt, min(0), max(120))
-  age!: number;
+| Library | Valid | Invalid | vs baker (valid) | vs baker (invalid) |
+|---|---|---|---|---|
+| **baker** | **42ns** | **93ns** | — | — |
+| TypeBox | 123ns | 112ns | 2.9x slower | 1.2x slower |
+| AJV | 142ns | 201ns | 3.4x slower | 2.2x slower |
+| ArkType | 145ns | 8,591ns | 3.4x slower | 92x slower |
+| Valibot | 281ns | 1,070ns | 6.7x slower | 12x slower |
+| Zod | 675ns | 7,948ns | 16x slower | 85x slower |
+| class-validator | 6,852ns | 10,109ns | 163x slower | 109x slower |
 
-  @Field(isEmail())
-  email!: string;
-}
-```
+## API
 
-### 2. Deserialize (auto-seals on first call)
+### `deserialize<T>(Class, input, options?)`
 
-```typescript
-import { deserialize, BakerValidationError } from '@zipbul/baker';
-
-try {
-  const user = await deserialize(CreateUserDto, requestBody);
-  // user is a validated CreateUserDto instance
-} catch (e) {
-  if (e instanceof BakerValidationError) {
-    console.log(e.errors); // BakerError[]
-  }
-}
-```
+Returns `T | BakerErrors | Promise<T | BakerErrors>`. Sync DTOs return directly — no Promise wrapping. Never throws on validation failure.
 
-### 3. Serialize
+### `serialize<T>(instance, options?)`
 
-```typescript
-import { serialize } from '@zipbul/baker';
+Returns `Record<string, unknown> | Promise<Record<string, unknown>>`. No validation. Sync DTOs return directly.
 
-const plain = await serialize(userInstance);
-// plain: Record<string, unknown>
-```
+### `validate(Class, input, options?)` / `validate(input, ...rules)`
 
-> No `seal()` call needed — baker auto-seals all registered DTOs on the first `deserialize()` or `serialize()` call.
+DTO-level or ad-hoc single-value validation. Returns `true | BakerErrors`.
 
----
+### `isBakerError(value)`
 
-## The `@Field()` Decorator
+Type guard. Narrows result to `BakerErrors` containing `{ path, code, message?, context? }[]`.
 
-`@Field()` is the single decorator that replaces all individual decorators. It accepts validation rules as positional arguments and an options object for advanced features.
+### `configure(config)`
 
-### Signatures
+Global configuration. Call before first deserialize/serialize/validate.
 
 ```typescript
-// Rules only
-@Field(isString, minLength(3), maxLength(100))
+configure({
+  autoConvert: true,        // coerce "123" → 123
+  allowClassDefaults: true, // use class field initializers for missing keys
+  stopAtFirstError: true,   // return on first validation failure
+  forbidUnknown: true,      // reject undeclared fields
+});
+```
 
-// Options only
-@Field({ optional: true, nullable: true })
+### `createRule(name, validate)`
 
-// Rules + options
-@Field(isString, { name: 'user_name', groups: ['create'] })
+Custom validation rule with optional AOT `emit()` for maximum performance.
 
-// No rules (plain field)
-@Field()
-```
+## @Field Decorator
 
-### FieldOptions
+One decorator for everything — replaces 30+ individual decorators from class-validator.
 
 ```typescript
-interface FieldOptions {
-  type?: () => Constructor | [Constructor];   // Nested DTO type (thunk for circular refs)
-  discriminator?: {                           // Polymorphic union
-    property: string;
-    subTypes: { value: Function; name: string }[];
-  };
-  keepDiscriminatorProperty?: boolean;        // Keep discriminator key in output
-  rules?: (EmittableRule | ArrayOfMarker)[];  // Validation rules (alternative to positional args)
-  optional?: boolean;                         // Allow undefined
-  nullable?: boolean;                         // Allow null
-  name?: string;                              // JSON key mapping (bidirectional)
-  deserializeName?: string;                   // Deserialize-only key mapping
-  serializeName?: string;                     // Serialize-only key mapping
-  exclude?: boolean | 'deserializeOnly' | 'serializeOnly';
-  groups?: string[];                          // Visibility + conditional validation
-  when?: (obj: any) => boolean;               // Conditional validation
-  schema?: JsonSchemaOverride;                // JSON Schema metadata
-  transform?: (params: FieldTransformParams) => unknown;
-  transformDirection?: 'deserializeOnly' | 'serializeOnly';
-  message?: string | ((args: MessageArgs) => string); // Error message for all rules
-  context?: unknown;                                   // Error context for all rules
-  mapValue?: () => Constructor;                        // Map value DTO type
-  setValue?: () => Constructor;                        // Set element DTO type
-}
+@Field(...rules)
+@Field(...rules, options)
+@Field(options)
 ```
 
-### Per-field Error Messages
+### Options
 
-Use `message` and `context` to customize validation error output:
+| Option | Type | Description |
+|---|---|---|
+| `type` | `() => Dto \| [Dto]` | Nested DTO. `[Dto]` for arrays |
+| `discriminator` | `{ property, subTypes }` | Polymorphic dispatch |
+| `optional` | `boolean` | Allow undefined |
+| `nullable` | `boolean` | Allow null |
+| `name` | `string` | Bidirectional key mapping |
+| `deserializeName` | `string` | Input key mapping |
+| `serializeName` | `string` | Output key mapping |
+| `exclude` | `boolean \| 'deserializeOnly' \| 'serializeOnly'` | Field exclusion |
+| `groups` | `string[]` | Conditional visibility |
+| `when` | `(obj) => boolean` | Conditional validation |
+| `transform` | `Transformer \| Transformer[]` | Value transformer |
+| `message` | `string \| (args) => string` | Error message override |
+| `context` | `unknown` | Error context |
+| `mapValue` | `() => Dto` | Map value DTO |
+| `setValue` | `() => Dto` | Set element DTO |
+
+## Transformers
+
+Bidirectional value transformers with separate `deserialize` and `serialize` methods.
 
 ```typescript
-@Field(isString, minLength(3), { message: 'Name is invalid' })
-name!: string;
+import type { Transformer } from '@zipbul/baker';
 
-@Field(isEmail(), {
-  message: ({ property, value }) => `${property} got bad value: ${value}`,
-  context: { severity: 'error' },
-})
-email!: string;
+const centsTransformer: Transformer = {
+  deserialize: ({ value }) => typeof value === 'number' ? value * 100 : value,
+  serialize: ({ value }) => typeof value === 'number' ? value / 100 : value,
+};
 ```
 
-The `message` and `context` are applied to all rules on the field. They appear in `BakerError.message` and `BakerError.context` on validation failure.
+### Built-in Transformers
 
-### `arrayOf()` — Array Element Validation
+```typescript
+import {
+  trimTransformer, toLowerCaseTransformer, toUpperCaseTransformer,
+  roundTransformer, unixSecondsTransformer, unixMillisTransformer,
+  isoStringTransformer, csvTransformer, jsonTransformer,
+} from '@zipbul/baker/transformers';
+```
 
-`arrayOf()` applies rules to each element of an array. Import it from `@zipbul/baker/rules` or `@zipbul/baker`.
+| Transformer | deserialize | serialize |
+|---|---|---|
+| `trimTransformer` | trim string | trim string |
+| `toLowerCaseTransformer` | lowercase | lowercase |
+| `toUpperCaseTransformer` | uppercase | uppercase |
+| `roundTransformer(n?)` | round to n decimals | round to n decimals |
+| `unixSecondsTransformer` | unix seconds &rarr; Date | Date &rarr; unix seconds |
+| `unixMillisTransformer` | unix ms &rarr; Date | Date &rarr; unix ms |
+| `isoStringTransformer` | ISO string &rarr; Date | Date &rarr; ISO string |
+| `csvTransformer(sep?)` | `"a,b"` &rarr; `["a","b"]` | `["a","b"]` &rarr; `"a,b"` |
+| `jsonTransformer` | JSON string &rarr; object | object &rarr; JSON string |
+
+### Transform Array Order
+
+Multiple transformers apply as a codec stack:
+- **Deserialize**: left to right — `[A, B, C]` applies A, then B, then C
+- **Serialize**: right to left — `[A, B, C]` applies C, then B, then A
 
 ```typescript
-import { Field, arrayOf } from '@zipbul/baker';
-import { isString, minLength } from '@zipbul/baker/rules';
-
-class TagsDto {
-  @Field(arrayOf(isString, minLength(1)))
-  tags!: string[];
-}
+@Field(isString, { transform: [trimTransformer, toLowerCaseTransformer] })
+email!: string;
+// deserialize "  HELLO  " → trim → toLowerCase → "hello"
+// serialize   "hello"     → toLowerCase → trim → "hello"
 ```
 
-You can mix `arrayOf()` with top-level array rules:
+### Optional Peer Transformers
 
 ```typescript
-import { arrayMinSize, arrayMaxSize } from '@zipbul/baker/rules';
+// bun add luxon
+import { luxonTransformer } from '@zipbul/baker/transformers';
+const luxon = await luxonTransformer({ zone: 'Asia/Seoul' });
 
-class ScoresDto {
-  @Field(arrayMinSize(1), arrayMaxSize(10), arrayOf(isInt, min(0), max(100)))
-  scores!: number[];
+class EventDto {
+  @Field({ transform: luxon }) startAt!: DateTime;
 }
 ```
 
----
-
-## Built-in Rules
+```typescript
+// bun add moment
+import { momentTransformer } from '@zipbul/baker/transformers';
+const mt = await momentTransformer({ format: 'YYYY-MM-DD' });
+```
 
-All rules are imported from `@zipbul/baker/rules` and passed as arguments to `@Field()`.
+## Rules
 
-> **Constants vs factory functions:** Some rules are pre-built constants (used without `()`) while others are factory functions that accept parameters (used with `()`). The tables below mark constants with a dagger symbol.
+104 built-in validation rules.
 
 ### Type Checkers
 
-| Rule | Description |
-|---|---|
-| `isString` | `typeof === 'string'` |
-| `isNumber(opts?)` | `typeof === 'number'` with NaN/Infinity/maxDecimalPlaces checks |
-| `isInt` | Integer check |
-| `isBoolean` | `typeof === 'boolean'` |
-| `isDate` | `instanceof Date && !isNaN` |
-| `isEnum(enumObj)` | Enum value check |
-| `isArray` | `Array.isArray()` |
-| `isObject` | `typeof === 'object'`, excludes null/Array |
+`isString`, `isInt`, `isBoolean`, `isDate`, `isArray`, `isObject` — constants, no `()` needed.
 
-> `isString`, `isInt`, `isBoolean`, `isDate`, `isArray`, `isObject` are constants (no parentheses needed). `isNumber(opts?)` and `isEnum(enumObj)` are factory functions.
+`isNumber(options?)`, `isEnum(entity)` — factories, require `()`.
 
-### Common
-
-| Rule | Description |
-|---|---|
-| `equals(val)` | Strict equality (`===`) |
-| `notEquals(val)` | Strict inequality (`!==`) |
-| `isEmpty` | `undefined`, `null`, or `''` |
-| `isNotEmpty` | Not `undefined`, `null`, or `''` |
-| `isIn(arr)` | Value is in the given array |
-| `isNotIn(arr)` | Value is not in the given array |
+### Numbers
 
-> `isEmpty` and `isNotEmpty` are constants. The rest are factory functions.
+`min(n)`, `max(n)`, `isPositive`, `isNegative`, `isDivisibleBy(n)`
 
-### Number
+### Strings
 
-| Rule | Description |
-|---|---|
-| `min(n, opts?)` | `value >= n` (supports `{ exclusive: true }`) |
-| `max(n, opts?)` | `value <= n` (supports `{ exclusive: true }`) |
-| `isPositive` | `value > 0` |
-| `isNegative` | `value < 0` |
-| `isDivisibleBy(n)` | `value % n === 0` |
+`minLength(n)`, `maxLength(n)`, `length(min, max)`, `contains(seed)`, `notContains(seed)`, `matches(regex)`
 
-> `isPositive` and `isNegative` are constants (no parentheses). `min()`, `max()`, and `isDivisibleBy()` are factory functions.
+### Formats
 
-### String
+`isEmail()`, `isURL()`, `isUUID(version?)`, `isIP(version?)`, `isISO8601()`, `isJSON`, `isJWT`, `isCreditCard`, `isIBAN()`, `isFQDN()`, `isMACAddress()`, `isBase64()`, `isHexColor`, `isSemVer`, `isMongoId`, `isPhoneNumber()`, `isStrongPassword()`, `isULID()`, `isCUID2()`
 
-All string rules require the value to be a `string` type.
+### Arrays
 
-| Rule | Kind | Description |
-|---|---|---|
-| `minLength(n)` | factory | Minimum length |
-| `maxLength(n)` | factory | Maximum length |
-| `length(min, max)` | factory | Length range |
-| `contains(seed)` | factory | Contains substring |
-| `notContains(seed)` | factory | Does not contain substring |
-| `matches(pattern, modifiers?)` | factory | Regex match |
-| `isLowercase` | constant | All lowercase |
-| `isUppercase` | constant | All uppercase |
-| `isAscii` | constant | ASCII only |
-| `isAlpha` | constant | Alphabetic only (en-US) |
-| `isAlphanumeric` | constant | Alphanumeric only (en-US) |
-| `isBooleanString` | constant | `'true'`, `'false'`, `'1'`, or `'0'` |
-| `isNumberString(opts?)` | factory | Numeric string |
-| `isDecimal(opts?)` | factory | Decimal string |
-| `isFullWidth` | constant | Full-width characters |
-| `isHalfWidth` | constant | Half-width characters |
-| `isVariableWidth` | constant | Mix of full-width and half-width |
-| `isMultibyte` | constant | Multibyte characters |
-| `isSurrogatePair` | constant | Surrogate pair characters |
-| `isHexadecimal` | constant | Hexadecimal string |
-| `isOctal` | constant | Octal string |
-| `isEmail(opts?)` | factory | Email format |
-| `isURL(opts?)` | factory | URL format (port range validated) |
-| `isUUID(version?)` | factory | UUID v1-v5 |
-| `isIP(version?)` | factory | IPv4 / IPv6 |
-| `isHexColor` | constant | Hex color (`#fff`, `#ffffff`) |
-| `isRgbColor(includePercent?)` | factory | RGB color string |
-| `isHSL` | constant | HSL color string |
-| `isMACAddress(opts?)` | factory | MAC address |
-| `isISBN(version?)` | factory | ISBN-10 / ISBN-13 |
-| `isISIN` | constant | ISIN (International Securities Identification Number) |
-| `isISO8601(opts?)` | factory | ISO 8601 date string |
-| `isISRC` | constant | ISRC (International Standard Recording Code) |
-| `isISSN(opts?)` | factory | ISSN (International Standard Serial Number) |
-| `isJWT` | constant | JSON Web Token |
-| `isLatLong(opts?)` | factory | Latitude/longitude string |
-| `isLocale` | constant | Locale string (e.g. `en_US`) |
-| `isDataURI` | constant | Data URI |
-| `isFQDN(opts?)` | factory | Fully qualified domain name |
-| `isPort` | constant | Port number string (0-65535) |
-| `isEAN` | constant | EAN (European Article Number) |
-| `isISO31661Alpha2` | constant | ISO 3166-1 alpha-2 country code |
-| `isISO31661Alpha3` | constant | ISO 3166-1 alpha-3 country code |
-| `isBIC` | constant | BIC (Bank Identification Code) / SWIFT code |
-| `isFirebasePushId` | constant | Firebase Push ID |
-| `isSemVer` | constant | Semantic version string |
-| `isMongoId` | constant | MongoDB ObjectId (24-char hex) |
-| `isJSON` | constant | Parseable JSON string |
-| `isBase32(opts?)` | factory | Base32 encoded |
-| `isBase58` | constant | Base58 encoded |
-| `isBase64(opts?)` | factory | Base64 encoded |
-| `isDateString(opts?)` | factory | Date string (configurable strict mode) |
-| `isMimeType` | constant | MIME type string |
-| `isCurrency(opts?)` | factory | Currency string |
-| `isMagnetURI` | constant | Magnet URI |
-| `isCreditCard` | constant | Credit card number (Luhn) |
-| `isIBAN(opts?)` | factory | IBAN |
-| `isByteLength(min, max?)` | factory | Byte length range |
-| `isHash(algorithm)` | factory | Hash string (md4, md5, sha1, sha256, sha384, sha512, etc.) |
-| `isRFC3339` | constant | RFC 3339 date-time string |
-| `isMilitaryTime` | constant | Military time (HH:MM) |
-| `isLatitude` | constant | Latitude string |
-| `isLongitude` | constant | Longitude string |
-| `isEthereumAddress` | constant | Ethereum address |
-| `isBtcAddress` | constant | Bitcoin address |
-| `isISO4217CurrencyCode` | constant | ISO 4217 currency code |
-| `isPhoneNumber` | constant | E.164 international phone number |
-| `isStrongPassword(opts?)` | factory | Strong password (configurable min length, uppercase, lowercase, numbers, symbols) |
-| `isTaxId(locale)` | factory | Tax ID for given locale |
-
-### Array
-
-| Rule | Description |
-|---|---|
-| `arrayContains(values)` | Contains all given elements |
-| `arrayNotContains(values)` | Contains none of the given elements |
-| `arrayMinSize(n)` | Minimum array length |
-| `arrayMaxSize(n)` | Maximum array length |
-| `arrayUnique()` | No duplicates |
-| `arrayNotEmpty()` | Not empty |
+`arrayMinSize(n)`, `arrayMaxSize(n)`, `arrayUnique()`, `arrayNotEmpty`, `arrayContains(values)`, `arrayOf(...rules)`
 
-### Date
+### Common
 
-| Rule | Description |
-|---|---|
-| `minDate(date)` | Minimum date |
-| `maxDate(date)` | Maximum date |
+`equals(val)`, `notEquals(val)`, `isIn(values)`, `isNotIn(values)`, `isEmpty`, `isNotEmpty`
 
-### Object
+### Date
 
-| Rule | Description |
-|---|---|
-| `isNotEmptyObject(opts?)` | At least one key (supports `{ nullable: true }` to ignore null-valued keys) |
-| `isInstance(Class)` | `instanceof` check against given class |
+`minDate(date)`, `maxDate(date)`
 
 ### Locale
 
-Locale-specific validators that accept a locale string parameter.
-
-| Rule | Description |
-|---|---|
-| `isMobilePhone(locale)` | Mobile phone number for the given locale (e.g. `'ko-KR'`, `'en-US'`, `'ja-JP'`) |
-| `isPostalCode(locale)` | Postal code for the given locale/country code (e.g. `'US'`, `'KR'`, `'GB'`) |
-| `isIdentityCard(locale)` | National identity card number for the given locale (e.g. `'KR'`, `'US'`, `'CN'`) |
-| `isPassportNumber(locale)` | Passport number for the given locale (e.g. `'US'`, `'KR'`, `'GB'`) |
-
----
+`isMobilePhone(locale)`, `isPostalCode(locale)`, `isIdentityCard(locale)`, `isPassportNumber(locale)`
 
-## Configuration
-
-Call `configure()` **before** the first `deserialize()`/`serialize()`:
+## Nested DTOs
 
 ```typescript
-import { configure } from '@zipbul/baker';
-
-configure({
-  autoConvert: false,        // Implicit type conversion ("123" -> 123)
-  allowClassDefaults: false, // Use class default values for missing keys
-  stopAtFirstError: false,   // Stop at first error or collect all
-  forbidUnknown: false,      // Reject undeclared fields
-  debug: false,              // Emit field exclusion comments in generated code
-});
-```
-
-`configure()` returns `{ warnings: string[] }` — if called after auto-seal, warnings describe which classes won't be affected.
-
----
-
-## Error Handling
-
-When validation fails, `deserialize()` throws a `BakerValidationError`:
-
-```typescript
-class BakerValidationError extends Error {
-  readonly errors: BakerError[];
-  readonly className: string;
+class AddressDto {
+  @Field(isString) city!: string;
 }
 
-interface BakerError {
-  readonly path: string;      // 'user.address.city'
-  readonly code: string;      // 'isString', 'min', 'isEmail'
-  readonly message?: string;  // Custom message
-  readonly context?: unknown; // Custom context
+class UserDto {
+  @Field({ type: () => AddressDto }) address!: AddressDto;
+  @Field({ type: () => [AddressDto] }) addresses!: AddressDto[];
 }
 ```
 
----
-
-## Nested Objects
-
-Use `type` option for nested DTO validation:
+## Collections
 
 ```typescript
-class AddressDto {
-  @Field(isString)
-  city!: string;
-}
-
 class UserDto {
-  @Field({ type: () => AddressDto })
-  address!: AddressDto;
-
-  // Array of nested DTOs
-  @Field({ type: () => [AddressDto] })
-  addresses!: AddressDto[];
+  @Field({ type: () => Set as any, setValue: () => TagDto }) tags!: Set<TagDto>;
+  @Field({ type: () => Map as any, mapValue: () => PriceDto }) prices!: Map<string, PriceDto>;
 }
 ```
 
-### Discriminator (Polymorphism)
+## Discriminator
 
 ```typescript
-class DogDto {
-  @Field(isString) breed!: string;
-}
-class CatDto {
-  @Field(isBoolean) indoor!: boolean;
-}
-
-class PetOwnerDto {
+class PetOwner {
   @Field({
-    type: () => DogDto,
+    type: () => CatDto,
     discriminator: {
-      property: 'type',
+      property: 'kind',
       subTypes: [
-        { value: DogDto, name: 'dog' },
         { value: CatDto, name: 'cat' },
+        { value: DogDto, name: 'dog' },
       ],
     },
-  })
-  pet!: DogDto | CatDto;
+  }) pet!: CatDto | DogDto;
 }
 ```
 
-Discriminator works in both directions — `deserialize()` switches on the property value, `serialize()` dispatches via `instanceof`.
-
-### Map / Set Collections
-
-Baker auto-converts between `Map`/`Set` and JSON-compatible types:
-
-```typescript
-// Set<primitive>: JSON array ↔ Set
-@Field({ type: () => Set })
-tags!: Set<string>;
-
-// Set<DTO>: JSON array of objects ↔ Set of DTO instances
-@Field({ type: () => Set, setValue: () => TagDto })
-tags!: Set<TagDto>;
-
-// Map<string, primitive>: JSON object ↔ Map
-@Field({ type: () => Map })
-config!: Map<string, unknown>;
-
-// Map<string, DTO>: JSON object ↔ Map of DTO instances
-@Field({ type: () => Map, mapValue: () => PriceDto })
-prices!: Map<string, PriceDto>;
-```
-
-Map keys are always strings (JSON constraint). JSON Schema maps `Set` to `{ type: 'array', uniqueItems: true }` and `Map` to `{ type: 'object', additionalProperties: ... }`.
-
----
-
 ## Inheritance
 
-Baker supports class inheritance. Child DTOs automatically inherit all `@Field()` decorators from parent classes. You can override or extend fields in child classes:
-
 ```typescript
 class BaseDto {
-  @Field(isString)
-  name!: string;
-}
-
-class ExtendedDto extends BaseDto {
-  @Field(isInt, min(0))
-  age!: number;
-  // `name` is inherited from BaseDto
-}
-```
-
----
-
-## Transform
-
-The `transform` option in `FieldOptions` lets you transform values during deserialization and/or serialization. Transform functions can be **async**.
-
-```typescript
-class UserDto {
-  @Field(isString, {
-    transform: ({ value, direction }) => {
-      return direction === 'deserialize'
-        ? (value as string).trim().toLowerCase()
-        : value;
-    },
-  })
-  email!: string;
-
-  @Field(isString, {
-    transform: async ({ value }) => {
-      return await someAsyncOperation(value);
-    },
-    transformDirection: 'deserializeOnly',
-  })
-  data!: string;
+  @Field(isString) id!: string;
 }
-```
-
----
-
-## Custom Rules
-
-```typescript
-import { createRule } from '@zipbul/baker';
 
-const isPositiveInt = createRule({
-  name: 'isPositiveInt',
-  validate: (value) => Number.isInteger(value) && (value as number) > 0,
-});
-
-class Dto {
-  @Field(isPositiveInt)
-  count!: number;
+class UserDto extends BaseDto {
+  @Field(isString) name!: string;
+  // inherits 'id' field with isString rule
 }
 ```
 
----
+## FAQ
 
-## Class-level JSON Schema Metadata
+### When should I use baker instead of class-validator?
 
-Use `collectClassSchema()` to attach class-level JSON Schema metadata (title, description, etc.) to a DTO. This metadata is merged into the output of `toJsonSchema()`.
+When performance matters. baker is 163x faster on valid input and 109x faster on invalid input, while providing the same decorator-based DX. baker also eliminates the `reflect-metadata` dependency.
 
-> `collectClassSchema` is a low-level API exported from `src/collect.ts`. It is not available as a subpath export and must be imported directly.
+### How does baker compare to Zod?
 
-```typescript
-import { collectClassSchema } from '@zipbul/baker/src/collect';
+Zod uses schema method chains (`z.string().email()`), baker uses decorators (`@Field(isString, isEmail())`). baker is 16x faster on valid input because it generates optimized code at definition time instead of interpreting schemas at runtime. Choose Zod if you need schema-first design; choose baker if you need class-based DTOs with maximum performance.
 
-class CreateUserDto {
-  @Field(isString) name!: string;
-  @Field(isEmail()) email!: string;
-}
+### Does baker support async validation?
 
-collectClassSchema(CreateUserDto, {
-  title: 'CreateUserRequest',
-  description: 'Payload for creating a new user',
-});
-```
+Yes. If any rule or transformer is async, baker automatically detects it at seal time and generates an async executor. Sync DTOs return values directly without Promise wrapping.
 
-For property-level schema overrides, use the `schema` option in `@Field()`:
+### Can I use baker with NestJS?
 
-```typescript
-class Dto {
-  @Field(isString, minLength(1), {
-    schema: { description: 'User display name', minLength: 5 },
-  })
-  name!: string;
-}
-```
+Yes. baker's `@Field` decorator works alongside NestJS pipes. Use `deserialize()` in a custom validation pipe.
 
----
+### How does the AOT code generation work?
 
-## JSON Schema
+On the first call to `deserialize`/`serialize`/`validate`, baker seals all registered DTOs: it analyzes field metadata, generates optimized JavaScript validation functions via `new Function()`, and caches them. Subsequent calls execute the pre-compiled functions directly.
 
-Generate JSON Schema Draft 2020-12 from your DTOs:
+## Exports
 
 ```typescript
-import { toJsonSchema } from '@zipbul/baker';
-
-const schema = toJsonSchema(CreateUserDto, {
-  direction: 'deserialize',  // 'deserialize' | 'serialize'
-  groups: ['create'],         // Filter by group
-  onUnmappedRule: (name) => { /* custom rules without schema mapping */ },
-});
+import { deserialize, validate, serialize, configure, createRule, Field, arrayOf, isBakerError, SealError } from '@zipbul/baker';
+import type { Transformer, TransformParams, BakerError, BakerErrors, FieldOptions, EmittableRule, RuntimeOptions } from '@zipbul/baker';
+import { isString, isEmail, isULID, isCUID2, ... } from '@zipbul/baker/rules';
+import { trimTransformer, jsonTransformer, ... } from '@zipbul/baker/transformers';
 ```
 
----
-
-## How It Works
-
-```
-Decorators (@Field)     auto-seal (first call)     deserialize() / serialize()
-   metadata         ->   new Function() codegen  ->   execute generated code
-```
-
-1. `@Field()` attaches validation metadata to class properties at definition time
-2. First `deserialize()`/`serialize()` call triggers **auto-seal** — reads all metadata, analyzes circular references, generates optimized JavaScript functions via `new Function()`
-3. Subsequent calls execute the generated function directly — no interpretation loops
-
----
-
-## Subpath Exports
-
-| Import path | Purpose |
-|---|---|
-| `@zipbul/baker` | Main API: `deserialize`, `serialize`, `configure`, `toJsonSchema`, `Field`, `arrayOf`, `createRule` |
-| `@zipbul/baker/rules` | Rule functions and constants: `isString`, `min()`, `isEmail()`, `arrayOf()`, etc. |
-
----
-
 ## License
 
-[MIT](./LICENSE)
+MIT