@zipbul/baker 4.0.0 → 5.1.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @zipbul/baker
 
+## 5.1.0
+
+### Minor Changes
+
+- 2d61542: Baker-scoped runtime: `deserialize`/`validate`/`serialize` (plus the `*Sync`/`*Async`
+  variants) are now methods on a `Baker` instance — `app.deserialize(Dto, input)`. Each
+  baker compiles its own executor per class into its own map, so the **same class sealed by
+  two bakers with different configs behaves per each baker's config** — apps in one process
+  never mix. An undecorated subclass resolves to its nearest sealed ancestor within that
+  baker. Same-config bakers transparently share one compiled executor via a `(class, config)`
+  cache (compile once, no behavior change).
+
+  **BREAKING CHANGE:** the global `deserialize`/`validate`/`serialize` functions (and their
+  `*Sync`/`*Async` variants) are removed from the package entry, along with the published
+  `SEALED` symbol (`RAW` remains on `@zipbul/baker/symbols`). Migrate `deserialize(Dto, input)`
+  to `app.deserialize(Dto, input)` on the `Baker` instance that sealed the class.
+
+## 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,21 +27,23 @@ Zero `reflect-metadata`. Sealed codegen.
 ## Quick Start
 
 ```typescript
-import { deserialize, isBakerIssueSet, Field, Recipe, seal } from '@zipbul/baker';
+import { Baker, Field, 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, {
+const result = baker.deserialize(UserDto, {
   name: 'Alice',
   age: 30,
   email: 'alice@test.com',
@@ -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.     |
+| `app.deserialize` / `app.validate` / `app.serialize` | Run that baker's compiled executors: 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;
 
@@ -138,8 +143,8 @@ class UserDto {
   displayName!: string;
 }
 
-deserialize(UserDto, input); // `ssn` is skipped
-deserialize(UserDto, input, { groups: ['admin'] }); // `ssn` is included
+baker.deserialize(UserDto, input); // `ssn` is skipped
+baker.deserialize(UserDto, input, { groups: ['admin'] }); // `ssn` is included
 ```
 
 A field with no `groups` is always included; a field tagged with `groups` participates only when a matching group is passed via [runtime options](#runtime-options). See [`RuntimeOptions`](#runtime-options) for the call-site shape.
@@ -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.
+`app.deserialize` / `app.serialize` / `app.validate` run that baker's compiled executors and throw `BakerError` if the class was not sealed by this baker.
 
-`deserialize` / `serialize` / `validate` throw `BakerError` if the DTO is not sealed.
+**Isolation:** each baker compiles its own executor per class into its own map, so the **same class sealed by two bakers behaves per each baker's config** — apps never mix. (An undecorated subclass resolves to its nearest sealed ancestor within that baker.)
 
 ### `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,11 +414,11 @@ 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
-const result = deserialize(UserDto, input);
+const result = baker.deserialize(UserDto, input);
 
 if (isBakerIssueSet(result)) {
   for (const issue of result.errors) {
@@ -436,11 +445,11 @@ Yes. If any rule or transformer is async, baker automatically detects it at seal
 
 ### Can I use baker with NestJS?
 
-Yes. baker's `@Field` decorator works alongside NestJS pipes. Use `deserialize()` in a custom validation pipe.
+Yes. baker's `@Field` decorator works alongside NestJS pipes. Use `app.deserialize()` (your `Baker` instance) in a custom validation pipe.
 
 ### 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 in that baker's map. Subsequent `app.deserialize` / `app.serialize` / `app.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,10 @@ Calling `seal()` once at app startup walks every registered DTO, analyzes field
 
 ```typescript
 import {
-  seal,
-  deserialize, deserializeSync, deserializeAsync,
-  validate, validateSync, validateAsync,
-  serialize, serializeSync, serializeAsync,
-  configure, createRule, Field, Recipe, arrayOf, isBakerIssueSet, BakerError,
+  Baker, // .deserialize / .validate / .serialize (+ *Sync / *Async) live on the instance
+  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,7 @@
-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{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,42 @@
 import type { BakerConfig } from './configure';
+import type { BakerIssueSet } from './errors';
+import type { RuntimeOptions } from './interfaces';
 /**
- * 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 + runtime boundary. Each `new Baker()` owns its own
+ * registry, config, and compiled executors, so multiple bakers in one process (or a bundler-duplicated
+ * copy of the library) never fragment each other. `@Field` and the rule factories stay global (they
+ * write class-intrinsic schema); registration (`Recipe`), sealing (`seal`), and running
+ * (`deserialize`/`serialize`/`validate`) all 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
+ * app.deserialize(UserDto, input);
  * ```
+ *
+ * Isolation boundary is class identity, scoped per baker: the SAME class sealed by two bakers with
+ * different configs behaves per each baker's config (each compiles its own executor into its own map).
+ *
+ * `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;
+    deserialize: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => T | BakerIssueSet | Promise<T | BakerIssueSet>;
+    deserializeSync: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => T | BakerIssueSet;
+    deserializeAsync: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => Promise<T | BakerIssueSet>;
+    validate: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => true | BakerIssueSet | Promise<true | BakerIssueSet>;
+    validateSync: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => true | BakerIssueSet;
+    validateAsync: <T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions) => Promise<true | BakerIssueSet>;
+    serialize: <T>(instance: T, options?: RuntimeOptions) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    serializeSync: <T>(instance: T, options?: RuntimeOptions) => Record<string, unknown>;
+    serializeAsync: <T>(instance: T, options?: RuntimeOptions) => Promise<Record<string, unknown>>;
+}

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{#G=new Set;#F=new Map;#H;#I=!1;constructor(j){this.#H=j===void 0?Object.freeze({}):K(j)}Recipe=(j,F)=>{this.#G.add(j)};seal=()=>{if(this.#I)return;_(this.#G,this.#H,this.#F);this.#I=!0};#j(j){let F=j;while(F){const H=this.#F.get(F);if(H){if(F!==j)this.#F.set(j,H);return H}const J=Object.getPrototypeOf(F);F=typeof J==="function"?J:null}const G=j.name||"<anonymous class>";throw new L(`${G} is not sealed by this baker`)}deserialize=(j,F,G)=>M(this.#j(j),F,G);deserializeSync=(j,F,G)=>N(this.#j(j),j.name,F,G);deserializeAsync=(j,F,G)=>P(this.#j(j),F,G);validate=(j,F,G)=>X(this.#j(j),F,G);validateSync=(j,F,G)=>Y(this.#j(j),j.name,F,G);validateAsync=(j,F,G)=>Z(this.#j(j),F,G);serialize=(j,F)=>Q(this.#j(I(j,"serialize")),j,F);serializeSync=(j,F)=>{const G=I(j,"serializeSync");return U(this.#j(G),G.name,j,F)};serializeAsync=(j,F)=>W(this.#j(I(j,"serializeAsync")),j,F)}import{normalizeConfig as K}from"./configure.js";import{BakerError as L}from"./errors.js";import{runDeserialize as M,runDeserializeSync as N,runDeserializeAsync as P}from"./functions/deserialize.js";import{resolveSerializeClass as I,runSerialize as Q,runSerializeSync as U,runSerializeAsync as W}from"./functions/serialize.js";import{runValidate as X,runValidateSync as Y,runValidateAsync as Z}from"./functions/validate.js";import{sealRegistry as _}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

@@ -1,19 +1,7 @@
 import type { RuntimeOptions } from '../interfaces';
+import type { SealedExecutors } from '../types';
 import { type BakerIssueSet } from '../errors';
-/**
- * Converts input to a Class instance + validates.
- * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
- * - Sync DTOs return directly; async DTOs return Promise
- * - Success: T
- * - Validation failure: BakerIssueSet (use isBakerIssueSet() to narrow)
- */
-export declare function deserialize<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): T | BakerIssueSet | Promise<T | BakerIssueSet>;
-/**
- * Sync-asserted deserialize. Throws `BakerError` if Class has any async rule/transform
- * on the deserialize side.
- */
-export declare function deserializeSync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): T | BakerIssueSet;
-/**
- * Async-asserted deserialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-export declare function deserializeAsync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): Promise<T | BakerIssueSet>;
+declare function runDeserialize<T>(sealed: SealedExecutors<unknown>, input: unknown, options?: RuntimeOptions): T | BakerIssueSet | Promise<T | BakerIssueSet>;
+declare function runDeserializeSync<T>(sealed: SealedExecutors<unknown>, className: string, input: unknown, options?: RuntimeOptions): T | BakerIssueSet;
+declare function runDeserializeAsync<T>(sealed: SealedExecutors<unknown>, input: unknown, options?: RuntimeOptions): Promise<T | BakerIssueSet>;
+export { runDeserialize, runDeserializeSync, runDeserializeAsync };

package/dist/src/functions/deserialize.js

@@ -1 +1 @@
-import{isErr as H}from"@zipbul/result";import{toBakerIssueSet as J,BakerError as M}from"../errors.js";import{ensureSealed as K}from"../seal/seal.js";import{checkCallOptions as L}from"./check-call-options.js";export function deserialize(F,j,G){const q=L(G),g=K(F);if(g.isAsync)return g.deserialize(j,q).then((x)=>{if(H(x))return J(x.data);return x});const f=g.deserialize(j,q);if(H(f))return J(f.data);return f}export function deserializeSync(F,j,G){const q=L(G),g=K(F);if(g.isAsync)throw new M(`deserializeSync(${F.name}): DTO has async rules/transforms. Use deserializeAsync() instead.`);const f=g.deserialize(j,q);if(H(f))return J(f.data);return f}export function deserializeAsync(F,j,G){const q=L(G),g=K(F);if(g.isAsync)return g.deserialize(j,q).then((x)=>{if(H(x))return J(x.data);return x});const f=g.deserialize(j,q);if(H(f))return Promise.resolve(J(f.data));return Promise.resolve(f)}
+import{isErr as x}from"@zipbul/result";import{toBakerIssueSet as F,BakerError as H}from"../errors.js";import{checkCallOptions as G}from"./check-call-options.js";function runDeserialize(g,q,w){const v=G(w);if(g.isAsync)return g.deserialize(q,v).then((f)=>{if(x(f))return F(f.data);return f});const j=g.deserialize(q,v);if(x(j))return F(j.data);return j}function runDeserializeSync(g,q,w,v){const j=G(v);if(g.isAsync)throw new H(`deserializeSync(${q}): DTO has async rules/transforms. Use deserializeAsync() instead.`);const f=g.deserialize(w,j);if(x(f))return F(f.data);return f}function runDeserializeAsync(g,q,w){const v=G(w);if(g.isAsync)return g.deserialize(q,v).then((f)=>{if(x(f))return F(f.data);return f});const j=g.deserialize(q,v);if(x(j))return Promise.resolve(F(j.data));return Promise.resolve(j)}export{runDeserialize,runDeserializeSync,runDeserializeAsync};

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

@@ -1,16 +1,11 @@
 import type { RuntimeOptions } from '../interfaces';
+import type { SealedExecutors } from '../types';
 /**
- * Converts a Class instance to a plain object.
- * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
- * - Sync DTOs return directly; async DTOs return Promise
- * - No validation — always returns Record<string, unknown>
+ * Forgery check shared by the Baker serialize methods. Returns the validated constructor; resolution
+ * to a sealed executor is done by the caller from its baker map.
  */
-export declare function serialize<T>(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
-/**
- * Sync-asserted serialize. Throws `BakerError` if Class has any async transform on the serialize side.
- */
-export declare function serializeSync<T>(instance: T, options?: RuntimeOptions): Record<string, unknown>;
-/**
- * Async-asserted serialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-export declare function serializeAsync<T>(instance: T, options?: RuntimeOptions): Promise<Record<string, unknown>>;
+declare function resolveSerializeClass(instance: unknown, fnName: string): Function;
+declare function runSerialize<T>(sealed: SealedExecutors<unknown>, instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
+declare function runSerializeSync<T>(sealed: SealedExecutors<unknown>, className: string, instance: T, options?: RuntimeOptions): Record<string, unknown>;
+declare function runSerializeAsync<T>(sealed: SealedExecutors<unknown>, instance: T, options?: RuntimeOptions): Promise<Record<string, unknown>>;
+export { resolveSerializeClass, runSerialize, runSerializeSync, runSerializeAsync };

package/dist/src/functions/serialize.js

@@ -1 +1 @@
-import{BakerError as x}from"../errors.js";import{ensureSealed as I}from"../seal/seal.js";import{checkCallOptions as F}from"./check-call-options.js";function G(b,q){if(b==null||typeof b!=="object")throw new x(`${q}: expected a class instance, got ${b===null?"null":typeof b}`);const g=b.constructor;if(typeof g!=="function")throw new x(`${q}: instance has no constructor`);if(g===Object||!(b instanceof g))throw new x(`${q}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);return I(g)}export function serialize(b,q){const g=F(q),j=G(b,"serialize");return j.isSerializeAsync?j.serialize(b,g):j.serialize(b,g)}export function serializeSync(b,q){const g=F(q),j=G(b,"serializeSync");if(j.isSerializeAsync){const H=b.constructor.name;throw new x(`serializeSync(${H}): DTO has async serialize transforms. Use serializeAsync() instead.`)}return j.serialize(b,g)}export function serializeAsync(b,q){const g=F(q),j=G(b,"serializeAsync");return j.isSerializeAsync?j.serialize(b,g):Promise.resolve(j.serialize(b,g))}
+import{BakerError as w}from"../errors.js";import{checkCallOptions as x}from"./check-call-options.js";function resolveSerializeClass(b,g){if(b==null||typeof b!=="object")throw new w(`${g}: expected a class instance, got ${b===null?"null":typeof b}`);const j=b.constructor;if(typeof j!=="function")throw new w(`${g}: instance has no constructor`);if(j===Object||!(b instanceof j))throw new w(`${g}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);return j}function runSerialize(b,g,j){const q=x(j);return b.isSerializeAsync?b.serialize(g,q):b.serialize(g,q)}function runSerializeSync(b,g,j,q){const D=x(q);if(b.isSerializeAsync)throw new w(`serializeSync(${g}): DTO has async serialize transforms. Use serializeAsync() instead.`);return b.serialize(j,D)}function runSerializeAsync(b,g,j){const q=x(j);return b.isSerializeAsync?b.serialize(g,q):Promise.resolve(b.serialize(g,q))}export{resolveSerializeClass,runSerialize,runSerializeSync,runSerializeAsync};

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

@@ -1,18 +1,7 @@
 import type { BakerIssueSet } from '../errors';
 import type { RuntimeOptions } from '../interfaces';
-/**
- * DTO-level validation — validates `input` against a decorated class's schema.
- * Sync DTOs return directly; async DTOs return Promise. To validate a single primitive without a
- * DTO, call the rule directly (e.g. `isEmail()(value)`).
- */
-declare function validate<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): true | BakerIssueSet | Promise<true | BakerIssueSet>;
-/**
- * Sync-asserted validate. Throws `BakerError` if Class has any async rule/transform
- * on the deserialize/validate side. Use when caller code assumes sync return.
- */
-declare function validateSync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): true | BakerIssueSet;
-/**
- * Async-asserted validate. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-declare function validateAsync<T>(Class: new (...args: never[]) => T, input: unknown, options?: RuntimeOptions): Promise<true | BakerIssueSet>;
-export { validate, validateSync, validateAsync };
+import type { SealedExecutors } from '../types';
+declare function runValidate(sealed: SealedExecutors<unknown>, input: unknown, options?: RuntimeOptions): true | BakerIssueSet | Promise<true | BakerIssueSet>;
+declare function runValidateSync(sealed: SealedExecutors<unknown>, className: string, input: unknown, options?: RuntimeOptions): true | BakerIssueSet;
+declare function runValidateAsync(sealed: SealedExecutors<unknown>, input: unknown, options?: RuntimeOptions): Promise<true | BakerIssueSet>;
+export { runValidate, runValidateSync, runValidateAsync };

package/dist/src/functions/validate.js

@@ -1 +1 @@
-import{toBakerIssueSet as F,BakerError as J}from"../errors.js";import{ensureSealed as G}from"../seal/seal.js";import{checkCallOptions as H}from"./check-call-options.js";function validate(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return f===null?!0:F(f)}function validateSync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)throw new J(`validateSync(${q.name}): DTO has async rules/transforms. Use validateAsync() instead.`);const f=b.validate(g,j);return f===null?!0:F(f)}function validateAsync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return Promise.resolve(f===null?!0:F(f))}export{validate,validateSync,validateAsync};
+import{toBakerIssueSet as w,BakerError as z}from"../errors.js";import{checkCallOptions as x}from"./check-call-options.js";function runValidate(b,g,v){const j=x(v);if(b.isAsync)return b.validate(g,j).then((f)=>f===null?!0:w(f));const q=b.validate(g,j);return q===null?!0:w(q)}function runValidateSync(b,g,v,j){const q=x(j);if(b.isAsync)throw new z(`validateSync(${g}): DTO has async rules/transforms. Use validateAsync() instead.`);const f=b.validate(v,q);return f===null?!0:w(f)}function runValidateAsync(b,g,v){const j=x(v);if(b.isAsync)return b.validate(g,j).then((f)=>f===null?!0:w(f));const q=b.validate(g,j);return Promise.resolve(q===null?!0:w(q))}export{runValidate,runValidateSync,runValidateAsync};

package/dist/src/meta-access.d.ts

@@ -1,10 +1,4 @@
-import type { RawClassMeta, SealedExecutors } from './types';
-export declare function getSealed(cls: Function): SealedExecutors<unknown> | undefined;
-/** Same as getSealed but throws if the class is not sealed — for callers that establish the invariant elsewhere. */
-export declare function requireSealed(cls: Function): SealedExecutors<unknown>;
-export declare function setSealed(cls: Function, exec: SealedExecutors<unknown>): void;
-export declare function hasSealedOwn(cls: Function): boolean;
-export declare function deleteSealed(cls: Function): void;
+import type { RawClassMeta } from './types';
 export declare function deleteRaw(cls: Function): void;
 export declare function getRaw(cls: Function): RawClassMeta | undefined;
 /** Same as getRaw but throws if the class has no @Field decorators — for callers that establish the invariant elsewhere. */
@@ -16,4 +10,3 @@ export declare function setRaw(cls: Function, raw: RawClassMeta): void;
  * the dual own-check keeps mergeInheritance from double-counting inherited fields.
  */
 export declare function hasRawOwn(cls: Function): boolean;
-export declare function freezeRaw(cls: Function): void;

package/dist/src/meta-access.js

@@ -1 +1 @@
-import{RAW as B,SEALED as q}from"./symbols.js";function C(j){return j[Symbol.metadata]??void 0}function F(j){if(!Object.hasOwn(j,Symbol.metadata))Object.defineProperty(j,Symbol.metadata,{value:{},writable:!0,configurable:!0,enumerable:!1});return j[Symbol.metadata]}export function getSealed(j){return j[q]}export function requireSealed(j){const k=j[q];if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class is not sealed`);return k}export function setSealed(j,k){j[q]=k}export function hasSealedOwn(j){return Object.hasOwn(j,q)}export function deleteSealed(j){delete j[q]}export function deleteRaw(j){if(Object.hasOwn(j,Symbol.metadata))delete j[Symbol.metadata][B]}export function getRaw(j){return C(j)?.[B]}export function requireRaw(j){const k=getRaw(j);if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class has no @Field decorators`);return k}export function setRaw(j,k){F(j)[B]=k}export function hasRawOwn(j){if(!Object.hasOwn(j,Symbol.metadata))return!1;const k=j[Symbol.metadata];return k!=null&&Object.hasOwn(k,B)}export function freezeRaw(j){if(!hasRawOwn(j))return;Object.freeze(getRaw(j))}
+import{RAW as x}from"./symbols.js";function z(j){return j[Symbol.metadata]??void 0}function B(j){if(!Object.hasOwn(j,Symbol.metadata))Object.defineProperty(j,Symbol.metadata,{value:{},writable:!0,configurable:!0,enumerable:!1});return j[Symbol.metadata]}export function deleteRaw(j){if(Object.hasOwn(j,Symbol.metadata))delete j[Symbol.metadata][x]}export function getRaw(j){return z(j)?.[x]}export function requireRaw(j){const q=getRaw(j);if(q===void 0)throw Error(`${j.name||"<anonymous>"}: class has no @Field decorators`);return q}export function setRaw(j,q){B(j)[x]=q}export function hasRawOwn(j){if(!Object.hasOwn(j,Symbol.metadata))return!1;const q=j[Symbol.metadata];return q!=null&&Object.hasOwn(q,x)}

package/dist/src/seal/deserialize-builder.d.ts

@@ -1,10 +1,10 @@
 import type { Result, ResultAsync } from '@zipbul/result';
 import type { SealOptions, RuntimeOptions } from '../interfaces';
-import type { RawClassMeta } from '../types';
+import type { RawClassMeta, SealedExecutors } from '../types';
 import { type BakerIssue } from '../errors';
 type DeserializeExecutor<T> = (input: unknown, opts?: RuntimeOptions) => Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
 type ValidateExecutor = (input: unknown, opts?: RuntimeOptions) => BakerIssue[] | null | Promise<BakerIssue[] | null>;
-declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): DeserializeExecutor<T>;
-declare function buildDeserializeCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, validateOnly: true): ValidateExecutor;
-declare function buildValidateCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean): ValidateExecutor;
+declare function buildDeserializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined): DeserializeExecutor<T>;
+declare function buildDeserializeCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined, validateOnly: true): ValidateExecutor;
+declare function buildValidateCode(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, needsCircularCheck: boolean, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined): ValidateExecutor;
 export { buildDeserializeCode, buildValidateCode };