@zipbul/baker 1.1.0 → 2.0.0

package/README.md

@@ -1,627 +1,267 @@
-<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>
-
----
-
-## 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
+# @zipbul/baker
+
+Decorator-based validation + transformation with inline code generation. Zero `reflect-metadata`.
 
 ```bash
 bun add @zipbul/baker
 ```
 
-> **Requirements:** Bun >= 1.0, `experimentalDecorators: true` in tsconfig.json
+Requires `"experimentalDecorators": true` in `tsconfig.json`.
 
-```jsonc
-// tsconfig.json
-{
-  "compilerOptions": {
-    "experimentalDecorators": true
-  }
-}
-```
+## API
 
----
+### `deserialize<T>(Class, input, options?): T | BakerErrors | Promise<T | BakerErrors>`
 
-## Quick Start
-
-### 1. Define a DTO
+Validates input and creates a class instance. Sync DTOs return directly. Async DTOs (async transform/rules) return Promise. Always safe to `await`.
 
 ```typescript
-import { Field } from '@zipbul/baker';
-import { isString, isInt, isEmail, min, max } from '@zipbul/baker/rules';
+import { deserialize, isBakerError, Field } from '@zipbul/baker';
+import { isString, isNumber, isEmail, min, minLength } from '@zipbul/baker/rules';
 
-class CreateUserDto {
-  @Field(isString)
-  name!: string;
+class UserDto {
+  @Field(isString, minLength(2)) name!: string;
+  @Field(isNumber(), min(0)) age!: number;
+  @Field(isString, isEmail()) email!: string;
+}
 
-  @Field(isInt, min(0), max(120))
-  age!: number;
+const result = await deserialize(UserDto, { name: 'Alice', age: 30, email: 'alice@test.com' });
 
-  @Field(isEmail())
-  email!: string;
+if (isBakerError(result)) {
+  console.log(result.errors); // { path: string, code: string }[]
+} else {
+  console.log(result.name);  // 'Alice'
 }
 ```
 
-### 2. Deserialize (auto-seals on first call)
+Never throws on validation failure. Throws `SealError` only for programming errors (no `@Field` decorators, banned field names).
 
-```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[]
-  }
-}
-```
+### `validate(Class, input, options?): true | BakerErrors | Promise<true | BakerErrors>`
 
-### 3. Serialize
+Same validation as `deserialize` without instance creation.
 
 ```typescript
-import { serialize } from '@zipbul/baker';
+import { validate, isBakerError } from '@zipbul/baker';
 
-const plain = await serialize(userInstance);
-// plain: Record<string, unknown>
+const result = await validate(UserDto, input);
+if (isBakerError(result)) { /* errors */ }
 ```
 
-> No `seal()` call needed — baker auto-seals all registered DTOs on the first `deserialize()` or `serialize()` call.
+### `validate(input, ...rules): true | BakerErrors | Promise<true | BakerErrors>`
 
----
+Ad-hoc single value validation. No DTO needed.
 
-## The `@Field()` Decorator
+```typescript
+const result = await validate('hello@test.com', isString, isEmail());
+// result === true
+```
 
-`@Field()` is the single decorator that replaces all individual decorators. It accepts validation rules as positional arguments and an options object for advanced features.
+### `serialize<T>(instance, options?): Record<string, unknown> | Promise<Record<string, unknown>>`
 
-### Signatures
+Converts a class instance to a plain object. No validation. Sync DTOs return directly.
 
 ```typescript
-// Rules only
-@Field(isString, minLength(3), maxLength(100))
-
-// Options only
-@Field({ optional: true, nullable: true })
-
-// Rules + options
-@Field(isString, { name: 'user_name', groups: ['create'] })
+import { serialize } from '@zipbul/baker';
 
-// No rules (plain field)
-@Field()
+const plain = await serialize(userInstance);
 ```
 
-### FieldOptions
+### `isBakerError(value): value is BakerErrors`
+
+Type guard. Narrows `deserialize`/`validate` result to error type.
 
 ```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
+interface BakerError {
+  readonly path: string;     // 'name', 'address.city', 'items[0].value'
+  readonly code: string;     // 'isString', 'minLength', 'invalidInput'
+  readonly message?: string; // custom message if set
+  readonly context?: unknown; // custom context if set
 }
 ```
 
-### Per-field Error Messages
+### `configure(config): ConfigureResult`
 
-Use `message` and `context` to customize validation error output:
+Global configuration. Call before first `deserialize`/`serialize`/`validate`.
 
 ```typescript
-@Field(isString, minLength(3), { message: 'Name is invalid' })
-name!: string;
-
-@Field(isEmail(), {
-  message: ({ property, value }) => `${property} got bad value: ${value}`,
-  context: { severity: 'error' },
-})
-email!: string;
-```
+import { configure } from '@zipbul/baker';
 
-The `message` and `context` are applied to all rules on the field. They appear in `BakerError.message` and `BakerError.context` on validation failure.
+configure({
+  autoConvert: true,        // "123" → 123. Default: false
+  allowClassDefaults: true, // use class field initializers for missing keys. Default: false
+  stopAtFirstError: true,   // return on first validation failure. Default: false
+  forbidUnknown: true,      // reject undeclared fields. Default: false
+});
+```
 
-### `arrayOf()` — Array Element Validation
+### `createRule(name, validate): EmittableRule`
 
-`arrayOf()` applies rules to each element of an array. Import it from `@zipbul/baker/rules` or `@zipbul/baker`.
+Creates a custom validation rule.
 
 ```typescript
-import { Field, arrayOf } from '@zipbul/baker';
-import { isString, minLength } from '@zipbul/baker/rules';
+import { createRule } from '@zipbul/baker';
 
-class TagsDto {
-  @Field(arrayOf(isString, minLength(1)))
-  tags!: string[];
-}
+const isEven = createRule('isEven', (v) => typeof v === 'number' && v % 2 === 0);
+
+const isUnique = createRule({
+  name: 'isUnique',
+  validate: async (v) => await db.checkUnique(v),
+  constraints: { table: 'users' },
+});
 ```
 
-You can mix `arrayOf()` with top-level array rules:
+## `@Field` Decorator
 
 ```typescript
-import { arrayMinSize, arrayMaxSize } from '@zipbul/baker/rules';
-
-class ScoresDto {
-  @Field(arrayMinSize(1), arrayMaxSize(10), arrayOf(isInt, min(0), max(100)))
-  scores!: number[];
-}
+@Field(...rules)
+@Field(...rules, options)
+@Field(options)
 ```
 
----
+### Options
 
-## Built-in Rules
-
-All rules are imported from `@zipbul/baker/rules` and passed as arguments to `@Field()`.
+```typescript
+interface FieldOptions {
+  type?: () => DtoClass | [DtoClass];        // nested DTO. [Dto] for arrays
+  discriminator?: {                           // polymorphic dispatch
+    property: string;
+    subTypes: { value: Function; name: string }[];
+  };
+  keepDiscriminatorProperty?: boolean;        // preserve discriminator in result. Default: false
+  rules?: EmittableRule[];                    // rules as array (alternative to variadic)
+  optional?: boolean;                         // allow undefined. Default: false
+  nullable?: boolean;                         // allow null. Default: false
+  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: any) => boolean;               // conditional validation
+  transform?: (params: FieldTransformParams) => unknown;     // value transform
+  transformDirection?: 'deserializeOnly' | 'serializeOnly';  // transform direction
+  message?: string | ((args) => string);      // error message override
+  context?: unknown;                          // error context
+  mapValue?: () => DtoClass;                  // Map value DTO
+  setValue?: () => DtoClass;                  // Set element DTO
+}
+```
 
-> **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.
+## 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` are constants (no parentheses needed). `isNumber(opts?)` and `isEnum(enumObj)` are factory functions.
-
-### 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 |
-
-> `isEmpty` and `isNotEmpty` are constants. The rest are factory functions.
-
-### Number
-
-| 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` |
-
-> `isPositive` and `isNegative` are constants (no parentheses). `min()`, `max()`, and `isDivisibleBy()` are factory functions.
-
-### String
-
-All string rules require the value to be a `string` type.
-
-| 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 |
+`isString`, `isInt`, `isBoolean`, `isDate`, `isArray`, `isObject` — constants, no `()`.
 
-### Date
+`isNumber(options?)`, `isEnum(entity)` — factories, need `()`.
 
-| Rule | Description |
-|---|---|
-| `minDate(date)` | Minimum date |
-| `maxDate(date)` | Maximum date |
+### Numbers
 
-### Object
+`min(n)`, `max(n)`, `min(n, { exclusive: true })`, `isPositive`, `isNegative`, `isDivisibleBy(n)`
 
-| Rule | Description |
-|---|---|
-| `isNotEmptyObject(opts?)` | At least one key (supports `{ nullable: true }` to ignore null-valued keys) |
-| `isInstance(Class)` | `instanceof` check against given class |
+### Strings
 
-### Locale
+`minLength(n)`, `maxLength(n)`, `length(min, max)`, `contains(seed)`, `notContains(seed)`, `matches(regex)`
 
-Locale-specific validators that accept a locale string parameter.
+### Formats
 
-| 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'`) |
+`isEmail()`, `isURL()`, `isUUID(version?)`, `isIP(version?)`, `isISO8601()`, `isJSON`, `isJWT`, `isCreditCard`, `isIBAN()`, `isFQDN()`, `isMACAddress()`, `isBase64()`, `isHexColor`, `isSemVer`, `isMongoId`, `isPhoneNumber`, `isStrongPassword()`
 
----
+### Arrays
 
-## Configuration
+`arrayMinSize(n)`, `arrayMaxSize(n)`, `arrayUnique()`, `arrayNotEmpty`, `arrayContains(values)`, `arrayOf(...rules)`
 
-Call `configure()` **before** the first `deserialize()`/`serialize()`:
+### Common
 
-```typescript
-import { configure } from '@zipbul/baker';
+`equals(val)`, `notEquals(val)`, `isIn(values)`, `isNotIn(values)`, `isEmpty`, `isNotEmpty`
 
-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
-});
-```
+### Date
 
-`configure()` returns `{ warnings: string[] }` — if called after auto-seal, warnings describe which classes won't be affected.
+`minDate(date)`, `maxDate(date)`
 
----
+### Locale
 
-## Error Handling
+`isMobilePhone(locale)`, `isPostalCode(locale)`, `isIdentityCard(locale)`, `isPassportNumber(locale)`
 
-When validation fails, `deserialize()` throws a `BakerValidationError`:
+## Nested DTOs
 
 ```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: () => TagDto }) tagMap!: Map<string, TagDto>;
 }
 ```
 
-### 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;
-}
-```
-
----
-
-## 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;
+  @Field(isString) id!: string;
 }
-```
-
----
-
-## Class-level JSON Schema Metadata
-
-Use `collectClassSchema()` to attach class-level JSON Schema metadata (title, description, etc.) to a DTO. This metadata is merged into the output of `toJsonSchema()`.
-
-> `collectClassSchema` is a low-level API exported from `src/collect.ts`. It is not available as a subpath export and must be imported directly.
-
-```typescript
-import { collectClassSchema } from '@zipbul/baker/src/collect';
 
-class CreateUserDto {
+class UserDto extends BaseDto {
   @Field(isString) name!: string;
-  @Field(isEmail()) email!: string;
-}
-
-collectClassSchema(CreateUserDto, {
-  title: 'CreateUserRequest',
-  description: 'Payload for creating a new user',
-});
-```
-
-For property-level schema overrides, use the `schema` option in `@Field()`:
-
-```typescript
-class Dto {
-  @Field(isString, minLength(1), {
-    schema: { description: 'User display name', minLength: 5 },
-  })
-  name!: string;
+  // inherits 'id' field with isString rule
 }
 ```
 
----
-
-## JSON Schema
-
-Generate JSON Schema Draft 2020-12 from your DTOs:
+## Exports
 
 ```typescript
-import { toJsonSchema } from '@zipbul/baker';
+// Functions
+import { deserialize, validate, serialize, configure, createRule } from '@zipbul/baker';
 
-const schema = toJsonSchema(CreateUserDto, {
-  direction: 'deserialize',  // 'deserialize' | 'serialize'
-  groups: ['create'],         // Filter by group
-  onUnmappedRule: (name) => { /* custom rules without schema mapping */ },
-});
-```
+// Decorators
+import { Field, arrayOf } from '@zipbul/baker';
 
----
+// Error handling
+import { isBakerError, SealError } from '@zipbul/baker';
 
-## How It Works
+// Types
+import type {
+  BakerError, BakerErrors, FieldOptions, FieldTransformParams,
+  ArrayOfMarker, EmittableRule, BakerConfig, ConfigureResult, RuntimeOptions,
+} from '@zipbul/baker';
 
+// Rules (subpath)
+import { isString, isNumber, ... } from '@zipbul/baker/rules';
 ```
-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. |
+## What Baker Does Not Do
 
----
+- JSON Schema / OpenAPI generation
+- GraphQL schema generation
+- Runtime type inference from schemas
+- `reflect-metadata` dependency
 
 ## License
 
-[MIT](./LICENSE)
+MIT