@zipbul/baker 4.0.0 → 5.0.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @zipbul/baker
 
+## 5.0.0
+
+### Major Changes
+
+- 8ea7162: Remove the global registration API in favor of the `Baker` class. `new Baker(config?)`
+  is now the only way to register and seal DTOs: use `@app.Recipe` to register a class and
+  `app.seal()` to seal it. The global `@Recipe`, `seal()`, `configure()`, and the `createBaker()`
+  factory have been removed — each `Baker` instance owns its own isolated registry and config, so
+  multiple apps in one process never mix. `@Field`, the rule/transformer factories, and
+  `deserialize`/`validate`/`serialize` are unchanged.
+
+  Migration: replace `configure(opts)` + global `@Recipe`/`seal()` with
+  `const app = new Baker(opts); @app.Recipe class Dto {}; app.seal();`.
+
 ## 4.0.0
 
 ### Major Changes

package/README.md

@@ -1,6 +1,6 @@
 # @zipbul/baker
 
-The fastest decorator-based DTO validation library for TypeScript. baker generates optimized validation and serialization code once at `seal()` time, then reuses the sealed executors on every call.
+The fastest decorator-based DTO validation library for TypeScript. baker generates optimized validation and serialization code once at seal time, then reuses the sealed executors on every call.
 
 ```bash
 bun add @zipbul/baker
@@ -27,18 +27,20 @@ Zero `reflect-metadata`. Sealed codegen.
 ## Quick Start
 
 ```typescript
-import { deserialize, isBakerIssueSet, Field, Recipe, seal } from '@zipbul/baker';
+import { Baker, Field, deserialize, isBakerIssueSet } from '@zipbul/baker';
 import { isString, isNumber, isEmail, min, minLength } from '@zipbul/baker/rules';
 
-@Recipe
+const baker = new Baker();
+
+@baker.Recipe
 class UserDto {
   @Field(isString, minLength(2)) name!: string;
   @Field(isNumber(), min(0)) age!: number;
   @Field(isString, isEmail()) email!: string;
 }
 
-// Call once at app startup, after every DTO has been imported.
-seal();
+// Call once at startup, after this baker's DTOs are defined.
+baker.seal();
 
 // All rules here are sync, so deserialize returns the value directly (no await).
 const result = deserialize(UserDto, {
@@ -61,10 +63,13 @@ if (isBakerIssueSet(result)) {
 
 | Concept | What it does |
 | ------------------- | ------------------------------------------------------------------------------ |
-| `@Recipe`           | Marks a class as a DTO and registers it with baker.                            |
-| `@Field(...rules)`  | Declares a validated field. Only `@Field` properties are part of the contract. |
-| `seal()`            | Compiles every registered DTO into executor functions. Call once, at startup.  |
-| `deserialize` / `validate` / `serialize` | Run the sealed executors: parse+validate, validate-only, or emit a plain object. |
+| `new Baker(config?)` | An isolated registration + seal scope. Multiple bakers never mix. Use `@app.Recipe` and `app.seal()`. |
+| `@app.Recipe`       | Marks a class as a DTO of that baker. Only `@Field` properties are part of the contract. |
+| `@Field(...rules)`  | Declares a validated field. Global — works with any baker.                     |
+| `app.seal()`        | Compiles that baker's DTOs into executor functions. Call once, at startup.     |
+| `deserialize` / `validate` / `serialize` | Global — run the sealed executors stored on the class: parse+validate, validate-only, or emit a plain object. |
+
+> Examples below assume a `const baker = new Baker()` in scope and a single `baker.seal()` after the DTOs are defined.
 
 ## Why baker?
 
@@ -122,7 +127,7 @@ Most fields need only rules. The options below cover nested, conditional, collec
 ### Conditional fields & custom messages
 
 ```typescript
-@Recipe
+@baker.Recipe
 class UserDto {
   @Field(isString) name!: string;
 
@@ -250,7 +255,7 @@ email!: string;
 import { luxonTransformer } from '@zipbul/baker/transformers';
 const luxon = await luxonTransformer({ zone: 'Asia/Seoul' });
 
-@Recipe
+@baker.Recipe
 class EventDto {
   @Field({ transform: luxon }) startAt!: DateTime;
 }
@@ -269,12 +274,12 @@ const mt = await momentTransformer({ format: 'YYYY-MM-DD' });
 ### Nested DTOs
 
 ```typescript
-@Recipe
+@baker.Recipe
 class AddressDto {
   @Field(isString) city!: string;
 }
 
-@Recipe
+@baker.Recipe
 class UserDto {
   @Field({ type: () => AddressDto }) address!: AddressDto;
   @Field({ type: () => [AddressDto] }) addresses!: AddressDto[];
@@ -284,7 +289,7 @@ class UserDto {
 ### Collections
 
 ```typescript
-@Recipe
+@baker.Recipe
 class UserDto {
   @Field({ type: () => Set, setValue: () => TagDto }) tags!: Set<TagDto>;
   @Field({ type: () => Map, mapValue: () => PriceDto }) prices!: Map<string, PriceDto>;
@@ -296,7 +301,7 @@ class UserDto {
 ### Discriminator
 
 ```typescript
-@Recipe
+@baker.Recipe
 class PetOwner {
   @Field({
     type: () => CatDto,
@@ -315,12 +320,12 @@ class PetOwner {
 ### Inheritance
 
 ```typescript
-@Recipe
+@baker.Recipe
 class BaseDto {
   @Field(isString) id!: string;
 }
 
-@Recipe
+@baker.Recipe
 class UserDto extends BaseDto {
   @Field(isString) name!: string;
   // inherits 'id' field with isString rule
@@ -329,11 +334,26 @@ class UserDto extends BaseDto {
 
 ## Runtime API
 
-### `seal()`
+### `new Baker(config?)`
+
+A `Baker` is an isolated registration + seal scope. Construct one per app/library; multiple bakers in one process never mix.
+
+- `@app.Recipe` — class decorator; registers the class as one of this baker's DTOs.
+- `app.seal()` — **required.** Compiles the baker's DTOs (and any nested DTOs they reach) into executor functions. Call once at startup, after the baker's DTOs are defined. Idempotent.
+- Config is passed to the constructor:
+
+```typescript
+const app = new Baker({
+  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
+});
+```
 
-**Required.** Call once at app startup, after every DTO module has been imported. Takes no arguments — seals every class registered via `@Recipe` so far, plus any nested DTOs they reach. Idempotent: a second call is a no-op.
+`deserialize` / `serialize` / `validate` are global — they read the sealed executor off the class — and throw `BakerError` if the class is not sealed.
 
-`deserialize` / `serialize` / `validate` throw `BakerError` if the DTO is not sealed.
+**Isolation:** distinct classes are fully isolated (each sealed with its baker's config). A class shared across bakers is sealed once (first seal wins) — use separate classes if you need different config.
 
 ### `deserialize` / `serialize` / `validate`
 
@@ -368,19 +388,6 @@ interface RuntimeOptions {
 
 Groups are passed at call time (not on `@Field`) because the active set typically varies per request.
 
-### `configure(config)`
-
-Global configuration. Must be called **before** `seal()`. After seal, `configure(...)` throws `BakerError`.
-
-```typescript
-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
-});
-```
-
 ### `createRule(name, validate)` / `createRule(options)`
 
 Custom validation rule. Two forms — a `(name, validate)` shorthand or an options object:
@@ -390,10 +397,12 @@ const koreanPhone = createRule('koreanPhone', v => /^01[016789]/.test(v as strin
 ```
 
 ```typescript
+import { RequiredType } from '@zipbul/baker';
+
 const isEven = createRule({
   name: 'isEven',
   validate: v => typeof v === 'number' && v % 2 === 0,
-  requiresType: 'number',
+  requiresType: RequiredType.Number,
 });
 ```
 
@@ -405,7 +414,7 @@ Type guard. Narrows a result to `BakerIssueSet`, whose `errors` array holds `{ p
 
 baker separates two failure modes:
 
-- **`BakerError` (thrown)** — a programming mistake: using a DTO before `seal()`, passing a raw rule function, calling `configure()` after seal, or calling a strict `*Sync` variant on an async DTO. Fix the code; don't catch it in request handlers.
+- **`BakerError` (thrown)** — a programming mistake: using a DTO before `app.seal()`, passing a raw rule function, an unknown config key, or calling a strict `*Sync` variant on an async DTO. Fix the code; don't catch it in request handlers.
 - **`BakerIssueSet` (returned)** — a validation failure. `deserialize` and `validate` return it instead of throwing. Guard with `isBakerIssueSet` and read `.errors`.
 
 ```typescript
@@ -440,7 +449,7 @@ Yes. baker's `@Field` decorator works alongside NestJS pipes. Use `deserialize()
 
 ### How does the AOT code generation work?
 
-Calling `seal()` once at app startup walks every registered DTO, analyzes field metadata, generates optimized JavaScript executor functions, and caches them. Subsequent `deserialize` / `serialize` / `validate` calls run the pre-compiled functions directly. There is no auto-seal — forgetting to call `seal()` raises `BakerError` on first use.
+Calling `app.seal()` once at startup walks the baker's DTOs (and their nested DTOs), analyzes field metadata, generates optimized JavaScript executor functions, and stores them on each class. Subsequent `deserialize` / `serialize` / `validate` calls run the pre-compiled functions directly. There is no auto-seal — using a DTO before `app.seal()` raises `BakerError`.
 
 > baker builds its executors with `new Function()`. Under a strict Content-Security-Policy this requires `'unsafe-eval'`; baker will not run in environments that forbid runtime code generation.
 
@@ -448,13 +457,13 @@ Calling `seal()` once at app startup walks every registered DTO, analyzes field
 
 ```typescript
 import {
-  seal,
+  Baker,
   deserialize, deserializeSync, deserializeAsync,
   validate, validateSync, validateAsync,
   serialize, serializeSync, serializeAsync,
-  configure, createRule, Field, Recipe, arrayOf, isBakerIssueSet, BakerError,
+  createRule, Field, arrayOf, isBakerIssueSet, BakerError, RequiredType, ExcludeMode,
 } from '@zipbul/baker';
-import type { Transformer, TransformParams, BakerIssue, BakerIssueSet, FieldOptions, EmittableRule, RuntimeOptions } from '@zipbul/baker';
+import type { Transformer, TransformParams, BakerIssue, BakerIssueSet, FieldOptions, EmittableRule, RuntimeOptions, BakerConfig } from '@zipbul/baker';
 import { isString, isEmail, isULID, isCUID2 /* …114 rules */ } from '@zipbul/baker/rules';
 import { trimTransformer, jsonTransformer /* …and more */ } from '@zipbul/baker/transformers';
 ```

package/dist/index.d.ts

@@ -1,13 +1,10 @@
 export { deserialize, deserializeSync, deserializeAsync } from './src/functions/deserialize';
 export { validate, validateSync, validateAsync } from './src/functions/validate';
 export { serialize, serializeSync, serializeAsync } from './src/functions/serialize';
-export { configure } from './src/configure';
 export { createRule } from './src/create-rule';
-export { seal } from './src/seal/seal';
-export { Field, arrayOf, Recipe } from './src/decorators/index';
+export { Field, arrayOf } from './src/decorators/index';
 export type { FieldOptions, ArrayOfMarker } from './src/decorators/index';
-export { createBaker } from './src/baker';
-export type { Baker } from './src/baker';
+export { Baker } from './src/baker';
 export { ExcludeMode, RequiredType } from './src/enums';
 export type { BakerIssue, BakerIssueSet } from './src/errors';
 export { isBakerIssueSet, BakerError } from './src/errors';

package/dist/index.js

@@ -1 +1 @@
-export{deserialize,deserializeSync,deserializeAsync}from"./src/functions/deserialize.js";export{validate,validateSync,validateAsync}from"./src/functions/validate.js";export{serialize,serializeSync,serializeAsync}from"./src/functions/serialize.js";export{configure}from"./src/configure.js";export{createRule}from"./src/create-rule.js";export{seal}from"./src/seal/seal.js";export{Field,arrayOf,Recipe}from"./src/decorators/index.js";export{createBaker}from"./src/baker.js";export{ExcludeMode,RequiredType}from"./src/enums.js";export{isBakerIssueSet,BakerError}from"./src/errors.js";
+export{deserialize,deserializeSync,deserializeAsync}from"./src/functions/deserialize.js";export{validate,validateSync,validateAsync}from"./src/functions/validate.js";export{serialize,serializeSync,serializeAsync}from"./src/functions/serialize.js";export{createRule}from"./src/create-rule.js";export{Field,arrayOf}from"./src/decorators/index.js";export{Baker}from"./src/baker.js";export{ExcludeMode,RequiredType}from"./src/enums.js";export{isBakerIssueSet,BakerError}from"./src/errors.js";

package/dist/src/baker.d.ts

@@ -1,26 +1,31 @@
 import type { BakerConfig } from './configure';
 /**
- * A baker scope — an isolated registration + seal boundary. Each `createBaker()` owns its own
- * registry and config; classes sealed through it are attributed to it, so separate scopes never
- * mix. `@Field`, rules, transformers, and `deserialize/serialize/validate` stay global (they read
- * the metadata/executor stored on the class), so only the class-collecting `Recipe` and `seal` are
- * scoped.
- */
-export interface Baker {
-    /** Class decorator — registers the class as a root of THIS scope. Use as `@app.Recipe`. */
-    readonly Recipe: (value: Function, context: ClassDecoratorContext) => void;
-    /** Seal every root registered to this scope (and its nested DTOs) with this scope's config. */
-    readonly seal: () => void;
-}
-/**
- * Create an isolated baker scope. Use for libraries and multi-app processes where each app must
- * not mix with another. Single-app code can keep using the global `@Recipe` / `seal()` / `configure()`.
+ * A baker — an isolated registration + seal boundary. Each `new Baker()` owns its own registry and
+ * config, so multiple bakers in one process (or a bundler-duplicated copy of the library) never
+ * fragment each other. `@Field`, the rule factories, and `deserialize`/`serialize`/`validate` stay
+ * global — they read the metadata/executor stored on the class itself — so only the class-collecting
+ * `Recipe` and `seal` belong to the instance.
  *
  * ```ts
- * const app = createBaker({ autoConvert: true });
+ * const app = new Baker({ autoConvert: true });
  * @app.Recipe class UserDto { @Field(isString) name!: string }
  * app.seal();
- * deserialize(UserDto, input); // global — reads UserDto's sealed executor
+ * deserialize(UserDto, input);
  * ```
+ *
+ * Isolation boundary is class identity: distinct classes are fully isolated (each sealed with its
+ * baker's config); a class shared across bakers is reused as one sealed form.
+ *
+ * `Recipe` and `seal` are arrow-field properties, not prototype methods, by design: `@app.Recipe`
+ * is applied as a detached value (the runtime calls the decorator with no `this` receiver), so it
+ * must be bound to the instance; arrow fields also keep `const { Recipe, seal } = new Baker()`
+ * working.
  */
-export declare function createBaker(config?: BakerConfig): Baker;
+export declare class Baker {
+    #private;
+    constructor(config?: BakerConfig);
+    /** Class decorator — registers the class as a root of this baker. Use as `@app.Recipe`. */
+    readonly Recipe: (value: Function, _context: ClassDecoratorContext) => void;
+    /** Seal every root registered to this baker (and its nested DTOs) with this baker's config. */
+    readonly seal: () => void;
+}

package/dist/src/baker.js

@@ -1 +1 @@
-import{normalizeConfig as H}from"./configure.js";import{sealRegistry as I}from"./seal/seal.js";export function createBaker(j){const q=new Set,E=j===void 0?Object.freeze({}):H(j);let A=!1;return{Recipe(G){q.add(G)},seal(){if(A)return;I(q,E);A=!0}}}
+export class Baker{#j=new Set;#q;#x=!1;constructor(j){this.#q=j===void 0?Object.freeze({}):q(j)}Recipe=(j,A)=>{this.#j.add(j)};seal=()=>{if(this.#x)return;x(this.#j,this.#q);this.#x=!0}}import{normalizeConfig as q}from"./configure.js";import{sealRegistry as x}from"./seal/seal.js";

package/dist/src/configure.d.ts

@@ -12,19 +12,8 @@ interface BakerConfig {
     debug?: boolean;
 }
 /**
- * Baker global configuration. Call before `seal()`.
- * If not called, defaults are applied.
- */
-declare function configure(config: BakerConfig): void;
-/**
- * Validate a BakerConfig and map it to the internal SealOptions. Shared by `configure()`
- * (default instance) and `createBaker()` (per-scope instances). Does NOT check seal state —
- * that gate is specific to the global `configure()`.
+ * Validate a BakerConfig and map it to the internal SealOptions. Used by `new Baker(config)`.
  */
 declare function normalizeConfig(config: BakerConfig): SealOptions;
-/** @internal — used by seal. Returns the frozen global options; the only way to change them is configure(). */
-declare function getGlobalOptions(): SealOptions;
-/** @internal — reset to defaults on unseal */
-declare function resetConfigForTesting(): void;
-export { configure, getGlobalOptions, resetConfigForTesting, normalizeConfig };
+export { normalizeConfig };
 export type { BakerConfig };

package/dist/src/configure.js

@@ -1 +1 @@
-import{BakerError as j}from"./errors.js";import{isSealed as x}from"./seal/seal-state.js";const w=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug"]);let q=Object.freeze({});function configure(h){if(x())throw new j("[baker] configure() called after seal(). Already-sealed classes are not affected. Call configure() before seal().");q=normalizeConfig(h)}function normalizeConfig(h){if(h===null||typeof h!=="object"||Array.isArray(h))throw new j(`[baker] config requires a plain object. Received: ${h===null?"null":Array.isArray(h)?"array":typeof h}.`);for(const v of Object.keys(h))if(!w.has(v))throw new j(`[baker] unknown key '${v}'. Valid keys: ${[...w].join(", ")}.`);return Object.freeze({enableImplicitConversion:h.autoConvert??!1,exposeDefaultValues:h.allowClassDefaults??!1,stopAtFirstError:h.stopAtFirstError??!1,whitelist:h.forbidUnknown??!1,debug:h.debug??!1})}function getGlobalOptions(){return q}function resetConfigForTesting(){q=Object.freeze({})}export{configure,getGlobalOptions,resetConfigForTesting,normalizeConfig};
+import{BakerError as u}from"./errors.js";const v=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug"]);function normalizeConfig(j){if(j===null||typeof j!=="object"||Array.isArray(j))throw new u(`[baker] config requires a plain object. Received: ${j===null?"null":Array.isArray(j)?"array":typeof j}.`);for(const q of Object.keys(j))if(!v.has(q))throw new u(`[baker] unknown key '${q}'. Valid keys: ${[...v].join(", ")}.`);return Object.freeze({enableImplicitConversion:j.autoConvert??!1,exposeDefaultValues:j.allowClassDefaults??!1,stopAtFirstError:j.stopAtFirstError??!1,whitelist:j.forbidUnknown??!1,debug:j.debug??!1})}export{normalizeConfig};

package/dist/src/decorators/index.d.ts

@@ -1,3 +1,2 @@
 export { Field, arrayOf } from './field';
 export type { FieldOptions, ArrayOfMarker } from './field';
-export { Recipe } from './recipe';

package/dist/src/decorators/index.js

@@ -1 +1 @@
-export{Field,arrayOf}from"./field.js";export{Recipe}from"./recipe.js";
+export{Field,arrayOf}from"./field.js";

package/dist/src/errors.d.ts

@@ -47,7 +47,7 @@ export declare function toBakerIssueSet(errors: BakerIssue[]): BakerIssueSet;
  *
  * Thrown when, e.g.:
  * - deserialize()/serialize()/validate() is called on an unsealed class
- * - configure() is called after seal(), or with an unknown key
+ * - new Baker() receives a config object with an unknown key or a non-plain-object
  * - seal-time metadata invariants fail (discriminator, Map keys, banned names, …)
  * - per-call options contain unsupported keys
  * - @Field receives a non-rule value, or a rule/transformer factory is misused

package/dist/src/errors.js

@@ -1 +1 @@
-export const BAKER_ERROR=Symbol.for("baker:error");export function isBakerIssueSet(j){return j!=null&&typeof j==="object"&&!Array.isArray(j)&&j[BAKER_ERROR]===!0}export function toBakerIssueSet(j){return{[BAKER_ERROR]:!0,errors:j}}export class BakerError extends Error{constructor(j,q){super(j,q);this.name="BakerError"}}
+export const BAKER_ERROR=Symbol.for("baker:error");export function isBakerIssueSet(q){return q!=null&&typeof q==="object"&&!Array.isArray(q)&&q[BAKER_ERROR]===!0}export function toBakerIssueSet(q){return{[BAKER_ERROR]:!0,errors:q}}export class BakerError extends Error{constructor(q,C){super(q,C);this.name="BakerError"}}

package/dist/src/functions/check-call-options.d.ts

@@ -2,7 +2,7 @@ import type { RuntimeOptions } from '../interfaces';
 /**
  * @internal — validate per-call options object at public-API entry.
  * `groups` is the only valid per-call key; everything else is rejected:
- *   - seal-time keys (BakerConfig / SealOptions) → "move to configure({...})"
+ *   - seal-time keys (BakerConfig / SealOptions) → "move to new Baker({...})"
  *   - any other key → "unknown call option"
  */
 export declare function checkCallOptions(opts: unknown): RuntimeOptions | undefined;

package/dist/src/functions/check-call-options.js

@@ -1 +1 @@
-import{BakerError as v}from"../errors.js";const x=new Set(["groups"]);const F=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug","enableImplicitConversion","exposeDefaultValues","whitelist"]);export function checkCallOptions(d){if(d===void 0||d===null)return;if(typeof d!=="object"||Array.isArray(d))throw new v(`Call options must be a plain object. Received: ${Array.isArray(d)?"array":typeof d}.`);const D=Object.getPrototypeOf(d);if(D!==null&&D!==Object.prototype){const q=d.constructor?.name??"unknown";throw new v(`Call options must be a plain object literal. Received instance of ${q}.`)}for(const q of Object.keys(d)){if(x.has(q))continue;if(F.has(q))throw new v(`Option '${q}' is a seal-time setting and cannot be passed per-call. Move it to configure({ ${q}: ... }) at app startup. Per-call options: ${[...x].join(", ")}.`);throw new v(`Unknown per-call option '${q}'. Valid per-call options: ${[...x].join(", ")}. Seal-time options go to configure({...}).`)}return d}
+import{BakerError as v}from"../errors.js";const x=new Set(["groups"]);const F=new Set(["autoConvert","allowClassDefaults","stopAtFirstError","forbidUnknown","debug","enableImplicitConversion","exposeDefaultValues","whitelist"]);export function checkCallOptions(d){if(d===void 0||d===null)return;if(typeof d!=="object"||Array.isArray(d))throw new v(`Call options must be a plain object. Received: ${Array.isArray(d)?"array":typeof d}.`);const D=Object.getPrototypeOf(d);if(D!==null&&D!==Object.prototype){const q=d.constructor?.name??"unknown";throw new v(`Call options must be a plain object literal. Received instance of ${q}.`)}for(const q of Object.keys(d)){if(x.has(q))continue;if(F.has(q))throw new v(`Option '${q}' is a seal-time setting and cannot be passed per-call. Move it to new Baker({ ${q}: ... }) at app startup. Per-call options: ${[...x].join(", ")}.`);throw new v(`Unknown per-call option '${q}'. Valid per-call options: ${[...x].join(", ")}. Seal-time options go to new Baker({...}).`)}return d}

package/dist/src/functions/deserialize.d.ts

@@ -2,7 +2,7 @@ import type { RuntimeOptions } from '../interfaces';
 import { type BakerIssueSet } from '../errors';
 /**
  * Converts input to a Class instance + validates.
- * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
+ * - Requires the class's baker to be sealed (`new Baker().seal()`) beforehand; throws `BakerError` if not sealed
  * - Sync DTOs return directly; async DTOs return Promise
  * - Success: T
  * - Validation failure: BakerIssueSet (use isBakerIssueSet() to narrow)

package/dist/src/functions/serialize.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeOptions } from '../interfaces';
 /**
  * Converts a Class instance to a plain object.
- * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
+ * - Requires the class's baker to be sealed (`new Baker().seal()`) beforehand; throws `BakerError` if not sealed
  * - Sync DTOs return directly; async DTOs return Promise
  * - No validation — always returns Record<string, unknown>
  */

package/dist/src/seal/seal.d.ts

@@ -4,38 +4,19 @@ import type { RawClassMeta, SealedExecutors } from '../types';
 declare function circularPlaceholder(className: string): SealedExecutors<unknown>;
 /**
  * @internal — used by serialize/deserialize. Returns the sealed executor.
- * Throws if the class was never sealed. Users must call `seal()` at app startup.
+ * Throws if the class was never sealed. Seal a class via `new Baker().seal()` first.
  */
 declare function ensureSealed(Class: Function): SealedExecutors<unknown>;
 /**
- * Seal every class in `registry` with `options`. Shared core of both the global default `seal()`
- * and per-scope `createBaker().seal()`. Transactional: on any failure every class sealed by this
- * call is rolled back. Clears `registry` on success.
+ * Seal every class in `registry` with `options`. The core used by `new Baker().seal()`.
+ * Transactional: on any failure every class sealed by this call is rolled back. Clears `registry`
+ * on success.
  *
- * A class already sealed (e.g. a shared value-type DTO reached from another scope's roots) is
+ * A class already sealed (e.g. a shared value-type DTO reached from another Baker's roots) is
  * reused as-is — class identity is the isolation boundary, so a shared class carries one sealed
- * behaviour. Distinct classes stay fully isolated because each is sealed with its scope's options.
- *
- * @param track Optional set recording successfully-sealed classes. The default seal passes the
- *              global `sealedClasses` so `unseal()` can restore them; instances pass nothing.
- */
-declare function sealRegistry(registry: Set<Function>, options: SealOptions, track?: Set<Function>): void;
-/**
- * Seal a single class (and its nested DTOs). Not part of the public API — `seal()` (argless)
- * is the only public entry. Exposed via `__testing__.sealClass` so tests can seal one class in
- * isolation. Class[Symbol.metadata][RAW] must exist; Class[SEALED] must not.
- * Transactional: on failure, every placeholder installed by this call (the class and any
- * nested DTO reached by recursion) is removed so a future seal attempt can re-run cleanly.
- */
-declare function sealOneClass(Class: Function): void;
-/**
- * Public — call once at app startup. Seals every @Recipe-decorated class (and its nested DTOs)
- * and clears the registry. Idempotent: a second call is a no-op.
- *
- * Baker requires this call before any deserialize/serialize/validate. There is no implicit seal.
- * All DTOs must be imported before this call — baker has no lazy/on-demand sealing.
+ * behaviour. Distinct classes stay fully isolated because each is sealed with its Baker's options.
  */
-declare function seal(): void;
+declare function sealRegistry(registry: Set<Function>, options: SealOptions): void;
 /**
  * Merges RAW metadata child-first along the prototype chain of Class.
  *
@@ -48,10 +29,4 @@ declare function seal(): void;
  * - flags: child takes priority, only missing flags are supplemented from parent
  */
 declare function mergeInheritance(Class: Function): RawClassMeta;
-declare const __testing__: {
-    mergeInheritance: typeof mergeInheritance;
-    circularPlaceholder: typeof circularPlaceholder;
-    sealClass: typeof sealOneClass;
-};
-export { ensureSealed, seal, sealRegistry, mergeInheritance, __testing__ };
-export { sealedClasses, resetForTesting } from './seal-state';
+export { ensureSealed, sealRegistry, mergeInheritance, circularPlaceholder };

package/dist/src/seal/seal.js

@@ -1 +1 @@
-import{getGlobalOptions as h}from"../configure.js";import{CollectionType as O,Direction as M}from"../enums.js";import{BakerError as G}from"../errors.js";import{deleteSealed as T,freezeRaw as I,getRaw as R,getSealed as E,hasRawOwn as f,hasSealedOwn as S,setSealed as g}from"../meta-access.js";import{globalRegistry as k}from"../registry.js";import{isAsyncFunction as u}from"../utils.js";import{analyzeCircular as y}from"./circular-analyzer.js";import{buildDeserializeCode as p,buildValidateCode as C}from"./deserialize-builder.js";import{validateExposeStacks as m}from"./expose-validator.js";import{sealedClasses as v,isSealed as n,markSealed as c}from"./seal-state.js";import{buildSerializeCode as d}from"./serialize-builder.js";import{validateMeta as o}from"./validate-meta.js";const i=new Set(["__proto__","constructor","prototype"]);const D=new Set([Number,String,Boolean,Date]);function A(H){const q=`Circular dependency during seal: ${H} is still being sealed`;return{deserialize(){throw new G(q)},serialize(){throw new G(q)},validate(){throw new G(q)},isAsync:!1,isSerializeAsync:!1}}function B(H,q,J){const Q=q===M.Deserialize?"isAsync":"isSerializeAsync",j=J??new Set,$=(X)=>{if(j.has(X))return!1;j.add(X);const W=E(X);if(W?.merged)return W[Q]===!0;return B(mergeInheritance(X),q,j)};for(const X of Object.values(H)){if(q===M.Deserialize&&X.validation.some((W)=>W.rule.isAsync))return!0;for(const W of X.transform){if(q===M.Deserialize?W.options?.serializeOnly:W.options?.deserializeOnly)continue;if(W.isAsync??u(W.fn))return!0}if(r(X).some($))return!0}return!1}function r(H){const q=H.type;if(!q)return[];const J=[];if(q.resolvedClass)J.push(q.resolvedClass);if(q.resolvedCollectionValue)J.push(q.resolvedCollectionValue);if(q.discriminator)for(const Q of q.discriminator.subTypes)J.push(Q.value);if(J.length===0&&q.fn){const Q=q.fn();if(Q===Map||Q===Set){const j=q.collectionValue?.();if(typeof j==="function"&&!D.has(j))J.push(j)}else{const j=Array.isArray(Q)?Q[0]:Q;if(typeof j==="function"&&!D.has(j))J.push(j)}}return J}function ensureSealed(H){const q=E(H);if(!q){const J=H.name||"<anonymous class>";throw new G(`${J} is not sealed. Call seal() at app startup before deserialize/validate/serialize. (If ${J} has no @Field decorators, decorate at least one property.)`)}return q}function t(){if(n())return;sealRegistry(k,h(),v);c()}function sealRegistry(H,q,J){const Q=new Set;try{for(const j of H)P(j,q,Q)}catch(j){for(const $ of Q)T($);throw j}for(const j of Q){J?.add(j);I(j)}H.clear()}function l(H){if(S(H))return;const q=h(),J=new Set;try{P(H,q,J)}catch(Q){for(const j of J)T(j);throw Q}for(const Q of J){v.add(Q);I(Q);k.delete(Q)}}function seal(){t()}function P(H,q,J){if(S(H))return;const Q=A(H.name);g(H,Q);try{const j=mergeInheritance(H);for(const U of Object.keys(j))if(i.has(U))throw new G(`${H.name}: field name '${U}' is not allowed (reserved property name)`);for(const[U,K]of Object.entries(j)){if(!K.type?.fn)continue;let F;try{F=K.type.fn()}catch(w){throw new G(`${H.name}.${U}: type function threw: ${w.message}`,{cause:w})}if(F===Map||F===Set){const w=F===Map?O.Map:O.Set,b={...K.type,collection:w,isArray:!1};if(K.type.collectionValue){let x;try{x=K.type.collectionValue()}catch(z){throw new G(`${H.name}.${U}: collectionValue function threw: ${z.message}`,{cause:z})}if(x!=null&&typeof x==="function"&&!D.has(x))b.resolvedCollectionValue=x}j[U]={...K,type:b};continue}const N=Array.isArray(F),V=N?F[0]:F;if(V==null||typeof V!=="function")throw new G(`${H.name}: @Type/@Field type must return a constructor or [constructor], got ${String(V)}`);const _={...K.type,isArray:N};if(!D.has(V)){_.resolvedClass=V;if(!K.flags.validateNested||!K.flags.validateNestedEach){K.flags={...K.flags};if(!K.flags.validateNested)K.flags.validateNested=!0;if(N&&!K.flags.validateNestedEach)K.flags.validateNestedEach=!0}}j[U]={...K,type:_}}m(j,H.name);o(H,j);const $=y(H);for(const U of Object.values(j)){if(U.type?.resolvedClass)P(U.type.resolvedClass,q,J);if(U.type?.resolvedCollectionValue)P(U.type.resolvedCollectionValue,q,J);if(U.type?.discriminator)for(const K of U.type.discriminator.subTypes)P(K.value,q,J)}const X=B(j,M.Deserialize),W=B(j,M.Serialize),L=p(H,j,q,$,X),Y=C(H,j,q,$,X),Z=d(H,j,q,W);Object.assign(Q,{deserialize:L,serialize:Z,validate:Y,isAsync:X,isSerializeAsync:W,merged:j})}catch(j){T(H);throw j}J?.add(H)}function mergeInheritance(H){const q=[];let J=H;while(J&&J!==Object){if(f(J))q.push(J);const $=Object.getPrototypeOf(J);J=$===J?null:$}const Q=Object.create(null),j=q.length>1;for(const $ of q){const X=R($);for(const[W,L]of Object.entries(X))if(!Q[W])Q[W]=j?{validation:[...L.validation],transform:[...L.transform],expose:[...L.expose],exclude:L.exclude,type:L.type,flags:{...L.flags}}:L;else{const Y=Q[W],Z=L;for(const F of Z.validation)if(!Y.validation.some((N)=>N.rule.ruleName===F.rule.ruleName))Y.validation.push(F);if(Y.transform.length===0&&Z.transform.length>0)Y.transform=[...Z.transform];if(Y.expose.length===0&&Z.expose.length>0)Y.expose=[...Z.expose];if(Y.exclude===null&&Z.exclude!==null)Y.exclude=Z.exclude;if(Y.type===null&&Z.type!==null)Y.type=Z.type;const U=Y.flags,K=Z.flags;if(K.isOptional!==void 0&&U.isOptional===void 0)U.isOptional=K.isOptional;if(K.isDefined!==void 0&&U.isDefined===void 0)U.isDefined=K.isDefined;if(K.validateIf!==void 0&&U.validateIf===void 0)U.validateIf=K.validateIf;if(K.isNullable!==void 0&&U.isNullable===void 0)U.isNullable=K.isNullable;if(K.validateNested!==void 0&&U.validateNested===void 0)U.validateNested=K.validateNested;if(K.validateNestedEach!==void 0&&U.validateNestedEach===void 0)U.validateNestedEach=K.validateNestedEach}}return Q}const __testing__={mergeInheritance,circularPlaceholder:A,sealClass:l};export{ensureSealed,seal,sealRegistry,mergeInheritance,__testing__};export{sealedClasses,resetForTesting}from"./seal-state.js";
+import{CollectionType as O,Direction as w}from"../enums.js";import{BakerError as F}from"../errors.js";import{deleteSealed as z,freezeRaw as S,getRaw as I,getSealed as h,hasRawOwn as E,hasSealedOwn as R,setSealed as k}from"../meta-access.js";import{isAsyncFunction as v}from"../utils.js";import{analyzeCircular as A}from"./circular-analyzer.js";import{buildDeserializeCode as f,buildValidateCode as g}from"./deserialize-builder.js";import{validateExposeStacks as u}from"./expose-validator.js";import{buildSerializeCode as y}from"./serialize-builder.js";import{validateMeta as p}from"./validate-meta.js";const C=new Set(["__proto__","constructor","prototype"]);const _=new Set([Number,String,Boolean,Date]);function circularPlaceholder(H){const j=`Circular dependency during seal: ${H} is still being sealed`;return{deserialize(){throw new F(j)},serialize(){throw new F(j)},validate(){throw new F(j)},isAsync:!1,isSerializeAsync:!1}}function b(H,j,J){const Q=j===w.Deserialize?"isAsync":"isSerializeAsync",q=J??new Set,L=(W)=>{if(q.has(W))return!1;q.add(W);const U=h(W);if(U?.merged)return U[Q]===!0;return b(mergeInheritance(W),j,q)};for(const W of Object.values(H)){if(j===w.Deserialize&&W.validation.some((U)=>U.rule.isAsync))return!0;for(const U of W.transform){if(j===w.Deserialize?U.options?.serializeOnly:U.options?.deserializeOnly)continue;if(U.isAsync??v(U.fn))return!0}if(n(W).some(L))return!0}return!1}function n(H){const j=H.type;if(!j)return[];const J=[];if(j.resolvedClass)J.push(j.resolvedClass);if(j.resolvedCollectionValue)J.push(j.resolvedCollectionValue);if(j.discriminator)for(const Q of j.discriminator.subTypes)J.push(Q.value);if(J.length===0&&j.fn){const Q=j.fn();if(Q===Map||Q===Set){const q=j.collectionValue?.();if(typeof q==="function"&&!_.has(q))J.push(q)}else{const q=Array.isArray(Q)?Q[0]:Q;if(typeof q==="function"&&!_.has(q))J.push(q)}}return J}function ensureSealed(H){const j=h(H);if(!j){const J=H.name||"<anonymous class>";throw new F(`${J} is not sealed. Call your baker's seal() (new Baker().seal()) at app startup before deserialize/validate/serialize. (If ${J} has no @Field decorators, decorate at least one property.)`)}return j}function sealRegistry(H,j){const J=new Set;try{for(const Q of H)P(Q,j,J)}catch(Q){for(const q of J)z(q);throw Q}for(const Q of J)S(Q);H.clear()}function P(H,j,J){if(R(H))return;const Q=circularPlaceholder(H.name);k(H,Q);try{const q=mergeInheritance(H);for(const K of Object.keys(q))if(C.has(K))throw new F(`${H.name}: field name '${K}' is not allowed (reserved property name)`);for(const[K,G]of Object.entries(q)){if(!G.type?.fn)continue;let $;try{$=G.type.fn()}catch(M){throw new F(`${H.name}.${K}: type function threw: ${M.message}`,{cause:M})}if($===Map||$===Set){const M=$===Map?O.Map:O.Set,B={...G.type,collection:M,isArray:!1};if(G.type.collectionValue){let V;try{V=G.type.collectionValue()}catch(T){throw new F(`${H.name}.${K}: collectionValue function threw: ${T.message}`,{cause:T})}if(V!=null&&typeof V==="function"&&!_.has(V))B.resolvedCollectionValue=V}q[K]={...G,type:B};continue}const x=Array.isArray($),N=x?$[0]:$;if(N==null||typeof N!=="function")throw new F(`${H.name}: @Type/@Field type must return a constructor or [constructor], got ${String(N)}`);const D={...G.type,isArray:x};if(!_.has(N)){D.resolvedClass=N;if(!G.flags.validateNested||!G.flags.validateNestedEach){G.flags={...G.flags};if(!G.flags.validateNested)G.flags.validateNested=!0;if(x&&!G.flags.validateNestedEach)G.flags.validateNestedEach=!0}}q[K]={...G,type:D}}u(q,H.name);p(H,q);const L=A(H);for(const K of Object.values(q)){if(K.type?.resolvedClass)P(K.type.resolvedClass,j,J);if(K.type?.resolvedCollectionValue)P(K.type.resolvedCollectionValue,j,J);if(K.type?.discriminator)for(const G of K.type.discriminator.subTypes)P(G.value,j,J)}const W=b(q,w.Deserialize),U=b(q,w.Serialize),Z=f(H,q,j,L,W),X=g(H,q,j,L,W),Y=y(H,q,j,U);Object.assign(Q,{deserialize:Z,serialize:Y,validate:X,isAsync:W,isSerializeAsync:U,merged:q})}catch(q){z(H);throw q}J?.add(H)}function mergeInheritance(H){const j=[];let J=H;while(J&&J!==Object){if(E(J))j.push(J);const L=Object.getPrototypeOf(J);J=L===J?null:L}const Q=Object.create(null),q=j.length>1;for(const L of j){const W=I(L);for(const[U,Z]of Object.entries(W))if(!Q[U])Q[U]=q?{validation:[...Z.validation],transform:[...Z.transform],expose:[...Z.expose],exclude:Z.exclude,type:Z.type,flags:{...Z.flags}}:Z;else{const X=Q[U],Y=Z;for(const $ of Y.validation)if(!X.validation.some((x)=>x.rule.ruleName===$.rule.ruleName))X.validation.push($);if(X.transform.length===0&&Y.transform.length>0)X.transform=[...Y.transform];if(X.expose.length===0&&Y.expose.length>0)X.expose=[...Y.expose];if(X.exclude===null&&Y.exclude!==null)X.exclude=Y.exclude;if(X.type===null&&Y.type!==null)X.type=Y.type;const K=X.flags,G=Y.flags;if(G.isOptional!==void 0&&K.isOptional===void 0)K.isOptional=G.isOptional;if(G.isDefined!==void 0&&K.isDefined===void 0)K.isDefined=G.isDefined;if(G.validateIf!==void 0&&K.validateIf===void 0)K.validateIf=G.validateIf;if(G.isNullable!==void 0&&K.isNullable===void 0)K.isNullable=G.isNullable;if(G.validateNested!==void 0&&K.validateNested===void 0)K.validateNested=G.validateNested;if(G.validateNestedEach!==void 0&&K.validateNestedEach===void 0)K.validateNestedEach=G.validateNestedEach}}return Q}export{ensureSealed,sealRegistry,mergeInheritance,circularPlaceholder};

package/dist/src/symbols.d.ts

@@ -4,5 +4,5 @@
  */
 /** Tier 1 collection metadata (stored on Class[Symbol.metadata] by decorators) */
 export declare const RAW: unique symbol;
-/** Tier 2 seal result (dual executor stored on Class by seal()) */
+/** Tier 2 seal result (dual executor stored on Class at seal time) */
 export declare const SEALED: unique symbol;

package/dist/src/types.d.ts

@@ -121,15 +121,15 @@ export interface TypeDef {
         }[];
     };
     keepDiscriminatorProperty?: boolean;
-    /** seal() normalization result — true if fn() returns an array */
+    /** seal-time normalization result — true if fn() returns an array */
     isArray?: boolean;
-    /** seal() normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
+    /** seal-time normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
     resolvedClass?: ClassCtor;
-    /** seal() normalization result — Map or Set collection type */
+    /** seal-time normalization result — Map or Set collection type */
     collection?: CollectionType;
     /** Nested DTO class thunk for Map value / Set element */
     collectionValue?: () => ClassCtor;
-    /** seal() normalization result — cached class after resolving collectionValue */
+    /** seal-time normalization result — cached class after resolving collectionValue */
     resolvedCollectionValue?: ClassCtor;
 }
 export interface PropertyFlags {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/baker",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "Bun-only AOT decorator-based DTO validation & serialization. class-validator DX, sealed code generation, zero reflect-metadata.",
   "keywords": [
     "aot",

package/dist/src/decorators/recipe.d.ts

@@ -1,17 +0,0 @@
-/**
- * Marks a class as a baker DTO so `seal()` (called with no arguments) discovers and seals it.
- *
- * Modern (TC39) field decorators receive no class reference, so `@Field` alone cannot register
- * the owning class. `@Recipe` runs after the field decorators and registers the class itself.
- *
- * @example
- * ```ts
- * \@Recipe
- * class UserDto {
- *   \@Field(isString()) name!: string;
- * }
- * seal();
- * ```
- */
-declare function Recipe<T extends Function>(value: T, _context: ClassDecoratorContext): void;
-export { Recipe };

package/dist/src/decorators/recipe.js

@@ -1 +0,0 @@
-import{globalRegistry as q}from"../registry.js";function Recipe(j,z){q.add(j)}export{Recipe};

package/dist/src/registry.d.ts

@@ -1,8 +0,0 @@
-/**
- * Global registry — automatically registers classes with at least one decorator attached
- *
- * - Automatically called from ensureMeta()
- * - seal() iterates this Set to seal all DTOs
- * - Metadata is not stored here — used only as an index (which classes are registered)
- */
-export declare const globalRegistry: Set<Function>;

package/dist/src/registry.js

@@ -1 +0,0 @@
-export const globalRegistry=new Set;

package/dist/src/seal/seal-state.d.ts

@@ -1,10 +0,0 @@
-/**
- * @internal — shared seal state, extracted so `configure.ts` can read `isSealed()`
- * without importing `seal.ts` (which would create a cycle: seal → configure → seal).
- */
-/** List of sealed classes — used by unseal to remove SEALED */
-export declare const sealedClasses: Set<Function>;
-export declare function isSealed(): boolean;
-export declare function markSealed(): void;
-/** @internal — used by unseal() in test helpers */
-export declare function resetForTesting(): void;

package/dist/src/seal/seal-state.js

@@ -1 +0,0 @@
-let c=!1;export const sealedClasses=new Set;export function isSealed(){return c}export function markSealed(){c=!0}export function resetForTesting(){c=!1;sealedClasses.clear()}