@zipbul/baker 2.1.0 → 3.0.0

package/dist/src/collect.d.ts

@@ -1,12 +1,15 @@
-import type { RawPropertyMeta, RuleDef, TransformDef, ExposeDef, ExcludeDef, TypeDef } from './types';
+import type { RawClassMeta, RawPropertyMeta } from './types';
+import { RAW } from './symbols';
+type MetaObject = Record<PropertyKey, unknown> & {
+    [RAW]?: RawClassMeta;
+};
 /**
- * Returns the RawPropertyMeta for the given propertyKey on ctor.
- * - Creates with default values if it doesn't exist.
- * - Automatically registers ctor in the global registry (registered if at least one decorator exists).
+ * Returns the RawPropertyMeta for the given propertyKey on the class's decorator metadata.
+ * Creates the RAW slot and the per-key default meta if absent.
+ *
+ * The own-RAW check is required: a subclass's metadata inherits the parent's RAW via the
+ * metadata prototype chain, so a bare assignment would pollute the parent. Creating a fresh
+ * own RAW (null prototype) keeps child fields isolated.
  */
-export declare function ensureMeta(ctor: Function, key: string): RawPropertyMeta;
-export declare function collectValidation(target: object, key: string, ruleDef: RuleDef): void;
-export declare function collectTransform(target: object, key: string, transformDef: TransformDef): void;
-export declare function collectExpose(target: object, key: string, exposeDef: ExposeDef): void;
-export declare function collectExclude(target: object, key: string, excludeDef: ExcludeDef): void;
-export declare function collectType(target: object, key: string, typeDef: TypeDef): void;
+export declare function ensureMeta(metadata: MetaObject, key: string): RawPropertyMeta;
+export {};

package/dist/src/collect.js

@@ -0,0 +1,26 @@
+import { RAW } from './symbols.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// ensureMeta — Internal utility (§3.1)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Returns the RawPropertyMeta for the given propertyKey on the class's decorator metadata.
+ * Creates the RAW slot and the per-key default meta if absent.
+ *
+ * The own-RAW check is required: a subclass's metadata inherits the parent's RAW via the
+ * metadata prototype chain, so a bare assignment would pollute the parent. Creating a fresh
+ * own RAW (null prototype) keeps child fields isolated.
+ */
+export function ensureMeta(metadata, key) {
+    if (!Object.hasOwn(metadata, RAW)) {
+        metadata[RAW] = Object.create(null);
+    }
+    const raw = metadata[RAW];
+    return (raw[key] ??= {
+        validation: [],
+        transform: [],
+        expose: [],
+        exclude: null,
+        type: null,
+        flags: {},
+    });
+}

package/dist/src/configure.d.ts

@@ -1,5 +1,5 @@
 import type { SealOptions } from './interfaces';
-export interface BakerConfig {
+interface BakerConfig {
     /** Automatic type conversion ("123" → 123). @default false */
     autoConvert?: boolean;
     /** Use class default values when key is missing from input. @default false */
@@ -11,17 +11,14 @@ export interface BakerConfig {
     /** Include field exclusion reasons as comments in generated code. @default false */
     debug?: boolean;
 }
-export interface ConfigureResult {
-    warnings: string[];
-}
 /**
- * Baker global configuration. Call before the first auto-seal.
+ * Baker global configuration. Call before `seal()`.
  * If not called, defaults are applied.
- *
- * @returns `{ warnings }` — contains warning messages if called after seal.
  */
-export declare function configure(config: BakerConfig): ConfigureResult;
-/** @internal — used by seal */
-export declare function _getGlobalOptions(): SealOptions;
+declare function configure(config: BakerConfig): void;
+/** @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 */
-export declare function _resetConfigForTesting(): void;
+declare function resetConfigForTesting(): void;
+export { configure, getGlobalOptions, resetConfigForTesting };
+export type { BakerConfig };

package/dist/src/configure.js

@@ -0,0 +1,43 @@
+import { BakerError } from './errors.js';
+import { isSealed } from './seal/seal-state.js';
+const BAKER_CONFIG_KEYS = new Set([
+    'autoConvert',
+    'allowClassDefaults',
+    'stopAtFirstError',
+    'forbidUnknown',
+    'debug',
+]);
+let globalOptionsState = Object.freeze({});
+/**
+ * Baker global configuration. Call before `seal()`.
+ * If not called, defaults are applied.
+ */
+function configure(config) {
+    if (isSealed()) {
+        throw new BakerError('[baker] configure() called after seal(). Already-sealed classes are not affected. Call configure() before seal().');
+    }
+    if (config === null || typeof config !== 'object' || Array.isArray(config)) {
+        throw new BakerError(`[baker] configure() requires a plain object. Received: ${config === null ? 'null' : Array.isArray(config) ? 'array' : typeof config}.`);
+    }
+    for (const key of Object.keys(config)) {
+        if (!BAKER_CONFIG_KEYS.has(key)) {
+            throw new BakerError(`[baker] configure(): unknown key '${key}'. ` + `Valid keys: ${[...BAKER_CONFIG_KEYS].join(', ')}.`);
+        }
+    }
+    globalOptionsState = Object.freeze({
+        enableImplicitConversion: config.autoConvert ?? false,
+        exposeDefaultValues: config.allowClassDefaults ?? false,
+        stopAtFirstError: config.stopAtFirstError ?? false,
+        whitelist: config.forbidUnknown ?? false,
+        debug: config.debug ?? false,
+    });
+}
+/** @internal — used by seal. Returns the frozen global options; the only way to change them is configure(). */
+function getGlobalOptions() {
+    return globalOptionsState;
+}
+/** @internal — reset to defaults on unseal */
+function resetConfigForTesting() {
+    globalOptionsState = Object.freeze({});
+}
+export { configure, getGlobalOptions, resetConfigForTesting };

package/dist/src/create-rule.d.ts

@@ -7,7 +7,7 @@ export interface CreateRuleOptions {
     /** Rule parameters */
     constraints?: Record<string, unknown>;
     /** Type assumed by this rule — used for type gate optimization */
-    requiresType?: 'string' | 'number' | 'boolean' | 'date';
+    requiresType?: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
 }
 /**
  * Creates a user-defined validation rule.

package/dist/src/create-rule.js

@@ -0,0 +1,41 @@
+import { BakerError } from './errors.js';
+import { defineRuleMetadata } from './rule-metadata.js';
+import { isAsyncFunction, isPromiseLike } from './utils.js';
+export function createRule(nameOrOptions, validateFn) {
+    const name = typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions.name;
+    const validate = typeof nameOrOptions === 'string' ? validateFn : nameOrOptions.validate;
+    // The overloads require `validate`; guard the untyped-JS path instead of asserting with `!`,
+    // so misuse fails clearly at creation rather than as a confusing TypeError at validation time.
+    if (typeof validate !== 'function') {
+        throw new BakerError(`createRule(${name}): a validate function is required.`);
+    }
+    const constraints = typeof nameOrOptions === 'object' ? nameOrOptions.constraints : undefined;
+    const requiresType = typeof nameOrOptions === 'object' ? nameOrOptions.requiresType : undefined;
+    const isAsyncFn = isAsyncFunction(validate);
+    // Validation function wrapper — enforces that sync rules stay sync.
+    const fn = function (value) {
+        const result = validate(value);
+        if (!isAsyncFn && isPromiseLike(result)) {
+            throw new BakerError(`createRule(${name}): sync rule returned Promise. Declare the validator with async if it is asynchronous.`);
+        }
+        return result;
+    };
+    // .emit() — generates function call code via the refs array
+    fn.emit = function (varName, ctx) {
+        const i = ctx.addRef(fn);
+        return `if(!(${isAsyncFn ? 'await ' : ''}refs[${i}](${varName}))) ${ctx.fail(name)};`;
+    };
+    const meta = {
+        emit: fn.emit,
+        ruleName: name,
+        isAsync: isAsyncFn,
+    };
+    if (constraints !== undefined) {
+        meta.constraints = constraints;
+    }
+    if (requiresType !== undefined) {
+        meta.requiresType = requiresType;
+    }
+    defineRuleMetadata(fn, meta);
+    return fn;
+}

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

@@ -1,5 +1,5 @@
-import type { EmittableRule, Transformer } from '../types';
-export interface ArrayOfMarker {
+import type { ClassCtor, EmittableRule, Transformer } from '../types';
+interface ArrayOfMarker {
     readonly [key: symbol]: true;
     readonly rules: EmittableRule[];
 }
@@ -7,13 +7,15 @@ export interface ArrayOfMarker {
  * Apply rules to each element of an array.
  *
  * @example
- * @Field(arrayOf(isString(), minLength(1)))
+ * ```ts
+ * \@Field(arrayOf(isString(), minLength(1)))
  * tags!: string[];
+ * ```
  */
-export declare function arrayOf(...rules: EmittableRule[]): ArrayOfMarker;
-export interface FieldOptions {
+declare function arrayOf(...rules: EmittableRule[]): ArrayOfMarker;
+interface FieldOptions {
     /** Nested DTO type. Thunk — supports circular references. [Dto] for arrays. */
-    type?: () => (new (...args: any[]) => any) | (new (...args: any[]) => any)[];
+    type?: () => ClassCtor | ClassCtor[] | MapConstructor | SetConstructor;
     /** Polymorphic discriminator configuration — used with type */
     discriminator?: {
         property: string;
@@ -41,7 +43,7 @@ export interface FieldOptions {
     /** Groups — field visibility control + conditional validation rule application */
     groups?: string[];
     /** Conditional validation — skip all field validation when false */
-    when?: (obj: Record<string, any>) => boolean;
+    when?: (obj: Record<string, unknown>) => boolean;
     /** Transformer or array of transformers (serialize direction applies in reverse order) */
     transform?: Transformer | Transformer[];
     /** Error message on validation failure — applied to all rules of the field (rule's own message takes precedence) */
@@ -53,17 +55,19 @@ export interface FieldOptions {
     /** Error context on validation failure — applied to all rules of the field (rule's own context takes precedence) */
     context?: unknown;
     /** Nested DTO class thunk for Map values — used with type: () => Map */
-    mapValue?: () => new (...args: any[]) => any;
+    mapValue?: () => ClassCtor;
     /** Nested DTO class thunk for Set elements — used with type: () => Set */
-    setValue?: () => new (...args: any[]) => any;
+    setValue?: () => ClassCtor;
 }
 type RuleArg = EmittableRule | ArrayOfMarker;
-/** @Field() — empty field registration */
-export declare function Field(): PropertyDecorator;
-/** @Field(isString(), email()) — variadic rules */
-export declare function Field(...rules: RuleArg[]): PropertyDecorator;
-/** @Field({ type: () => Dto }) — options object */
-export declare function Field(options: FieldOptions): PropertyDecorator;
-/** @Field(isString(), { optional: true }) — rules + options mixed */
-export declare function Field(...rulesAndOptions: [...RuleArg[], FieldOptions]): PropertyDecorator;
-export {};
+type FieldDecorator = (value: undefined, context: ClassFieldDecoratorContext) => void;
+/** `@Field`() — empty field registration */
+declare function Field(): FieldDecorator;
+/** `@Field`(isString(), email()) — variadic rules */
+declare function Field(...rules: RuleArg[]): FieldDecorator;
+/** `@Field`({ type: () => Dto }) — options object */
+declare function Field(options: FieldOptions): FieldDecorator;
+/** `@Field`(isString(), { optional: true }) — rules + options mixed */
+declare function Field(...rulesAndOptions: [...RuleArg[], FieldOptions]): FieldDecorator;
+export { arrayOf, Field };
+export type { ArrayOfMarker, FieldOptions };

package/dist/src/decorators/field.js

@@ -0,0 +1,268 @@
+import { ensureMeta } from '../collect.js';
+import { BakerError } from '../errors.js';
+import { isAsyncFunction, isPromiseLike } from '../utils.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// arrayOf — Array element validation marker (replaces each: true)
+// ─────────────────────────────────────────────────────────────────────────────
+const ARRAY_OF = Symbol.for('baker:arrayOf');
+/**
+ * Apply rules to each element of an array.
+ *
+ * @example
+ * ```ts
+ * \@Field(arrayOf(isString(), minLength(1)))
+ * tags!: string[];
+ * ```
+ */
+function arrayOf(...rules) {
+    const marker = { rules, [ARRAY_OF]: true };
+    return marker;
+}
+function isArrayOfMarker(arg) {
+    return typeof arg === 'object' && arg !== null && arg[ARRAY_OF] === true;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// FieldOptions detection — distinguish from EmittableRule/ArrayOfMarker
+// ─────────────────────────────────────────────────────────────────────────────
+const FIELD_OPTION_KEYS = new Set([
+    'type',
+    'discriminator',
+    'keepDiscriminatorProperty',
+    'rules',
+    'optional',
+    'nullable',
+    'name',
+    'deserializeName',
+    'serializeName',
+    'exclude',
+    'groups',
+    'when',
+    'transform',
+    'message',
+    'context',
+    'mapValue',
+    'setValue',
+]);
+function isFieldOptions(arg) {
+    if (typeof arg === 'function') {
+        return false;
+    }
+    if (typeof arg !== 'object' || arg === null) {
+        return false;
+    }
+    if (isArrayOfMarker(arg)) {
+        return false;
+    }
+    // Treat as FieldOptions if at least one known key exists
+    const keys = Object.keys(arg);
+    if (keys.length === 0) {
+        return true;
+    } // @Field({})
+    return keys.some(k => FIELD_OPTION_KEYS.has(k));
+}
+/** W5: assert that a value is a valid baker rule (has `.emit` fn + `.ruleName` string). */
+function assertRule(value, fieldKey, slot) {
+    const loc = slot ? `${fieldKey} ${slot}` : fieldKey;
+    const validForms = ` Valid @Field forms: @Field(), @Field(rule, ...), @Field(options), @Field(rule, ..., options).`;
+    if (typeof value === 'function') {
+        const fn = value;
+        if (typeof fn.emit !== 'function' || typeof fn.ruleName !== 'string') {
+            const hint = fn.name
+                ? ` Did you forget to call '${fn.name}()'? Factories must be invoked (e.g., '${fn.name}()'). Rule constants are passed directly (e.g., 'isString' without parentheses).`
+                : ` Use createRule() or import a rule from @zipbul/baker/rules.`;
+            throw new BakerError(`@Field on ${loc}: argument is not a baker rule.${hint}${validForms}`);
+        }
+        return;
+    }
+    throw new BakerError(`@Field on ${loc}: expected a baker rule (function with .emit and .ruleName), got ${value === null ? 'null' : typeof value}. Use createRule() or import a rule from @zipbul/baker/rules.${validForms}`);
+}
+/** Normalize 4 overload signatures into `{ rules, options }` */
+function parseFieldArgs(args) {
+    if (args.length === 0) {
+        // Form 1: @Field()
+        return { rules: [], options: {} };
+    }
+    if (args.length === 1 && isFieldOptions(args[0])) {
+        // Form 3: @Field({ type: () => Dto })
+        const options = args[0];
+        return { rules: options.rules ?? [], options };
+    }
+    // Form 2 or 4
+    const lastArg = args[args.length - 1];
+    if (isFieldOptions(lastArg)) {
+        // Form 4: @Field(isString(), { optional: true })
+        const options = lastArg;
+        let rules = args.slice(0, -1);
+        if (options.rules) {
+            rules = [...rules, ...options.rules];
+        }
+        return { rules, options };
+    }
+    // Form 2: @Field(isString(), email())
+    return { rules: args, options: {} };
+}
+/** Register validation rules + handle arrayOf */
+function applyValidation(meta, rules, options) {
+    for (const rule of rules) {
+        if (isArrayOfMarker(rule)) {
+            for (const innerRule of rule.rules) {
+                const rd = { rule: innerRule, each: true };
+                if (options.groups !== undefined) {
+                    rd.groups = options.groups;
+                }
+                if (options.message !== undefined) {
+                    rd.message = options.message;
+                }
+                if (options.context !== undefined) {
+                    rd.context = options.context;
+                }
+                meta.validation.push(rd);
+            }
+        }
+        else {
+            const rd = { rule: rule };
+            if (options.groups !== undefined) {
+                rd.groups = options.groups;
+            }
+            if (options.message !== undefined) {
+                rd.message = options.message;
+            }
+            if (options.context !== undefined) {
+                rd.context = options.context;
+            }
+            meta.validation.push(rd);
+        }
+    }
+}
+/** Handle expose 5-branch logic */
+function applyExpose(meta, options) {
+    if (options.name) {
+        const ed = { name: options.name };
+        if (options.groups !== undefined) {
+            ed.groups = options.groups;
+        }
+        meta.expose.push(ed);
+    }
+    else if (options.deserializeName || options.serializeName) {
+        if (options.deserializeName) {
+            const ed = { name: options.deserializeName, deserializeOnly: true };
+            if (options.groups !== undefined) {
+                ed.groups = options.groups;
+            }
+            meta.expose.push(ed);
+        }
+        if (options.serializeName) {
+            const ed = { name: options.serializeName, serializeOnly: true };
+            if (options.groups !== undefined) {
+                ed.groups = options.groups;
+            }
+            meta.expose.push(ed);
+        }
+    }
+    else if (options.groups) {
+        meta.expose.push({ groups: options.groups });
+    }
+    else {
+        meta.expose.push({});
+    }
+}
+/** Register Transformer — split into direction-specific TransformDefs */
+function wrapTransform(propertyKey, direction, fn) {
+    const isAsync = isAsyncFunction(fn);
+    const wrapped = (params => {
+        const result = fn(params);
+        if (!isAsync && isPromiseLike(result)) {
+            throw new BakerError(`@Field(${propertyKey}) ${direction} transform returned Promise. Declare the transform with async if it is asynchronous.`);
+        }
+        return result;
+    });
+    return { fn: wrapped, isAsync };
+}
+/** Register Transformer — split into direction-specific TransformDefs */
+function applyTransform(meta, propertyKey, options) {
+    if (!options.transform) {
+        return;
+    }
+    const transformers = Array.isArray(options.transform) ? options.transform : [options.transform];
+    for (const t of transformers) {
+        const deserialize = wrapTransform(propertyKey, 'deserialize', t.deserialize);
+        const serialize = wrapTransform(propertyKey, 'serialize', t.serialize);
+        meta.transform.push({ fn: deserialize.fn, isAsync: deserialize.isAsync, options: { deserializeOnly: true } }, { fn: serialize.fn, isAsync: serialize.isAsync, options: { serializeOnly: true } });
+    }
+}
+function Field(...args) {
+    return (_value, context) => {
+        if (context.static) {
+            throw new BakerError(`@Field cannot decorate static fields.`);
+        }
+        if (context.private) {
+            throw new BakerError(`@Field cannot decorate private fields.`);
+        }
+        if (typeof context.name === 'symbol') {
+            throw new BakerError(`@Field: symbol property keys are not supported. Use a string property name.`);
+        }
+        const propertyKey = context.name;
+        const meta = ensureMeta(context.metadata, propertyKey);
+        const { rules, options } = parseFieldArgs(args);
+        // `name` is bidirectional; `deserializeName`/`serializeName` are per-direction. Combining them
+        // is contradictory — reject it instead of silently dropping the per-direction names. Truthiness
+        // matches applyExpose: an empty-string name is treated as "no name" consistently throughout.
+        if (options.name && (options.deserializeName || options.serializeName)) {
+            throw new BakerError(`@Field on ${propertyKey}: 'name' cannot be combined with 'deserializeName'/'serializeName'. Use one or the other.`);
+        }
+        // W5: validate each rule shape — `.emit` function + `.ruleName` string required.
+        // Catches D2/D4: `@Field(isString())` (boolean), `@Field(isNumber)` (factory unstamped), `@Field(() => true)`.
+        for (let i = 0; i < rules.length; i++) {
+            const r = rules[i];
+            if (isArrayOfMarker(r)) {
+                for (let j = 0; j < r.rules.length; j++) {
+                    assertRule(r.rules[j], propertyKey, `arrayOf[${j}]`);
+                }
+            }
+            else {
+                assertRule(r, propertyKey);
+            }
+        }
+        applyValidation(meta, rules, options);
+        // ── flags ──
+        if (options.optional) {
+            meta.flags.isOptional = true;
+        }
+        if (options.nullable) {
+            meta.flags.isNullable = true;
+        }
+        if (options.when) {
+            meta.flags.validateIf = options.when;
+        }
+        // ── type (nested DTO + discriminator + collection) ──
+        if (options.type) {
+            const td = { fn: options.type };
+            if (options.discriminator !== undefined) {
+                td.discriminator = options.discriminator;
+            }
+            if (options.keepDiscriminatorProperty !== undefined) {
+                td.keepDiscriminatorProperty = options.keepDiscriminatorProperty;
+            }
+            const cv = options.mapValue ?? options.setValue;
+            if (cv !== undefined) {
+                td.collectionValue = cv;
+            }
+            meta.type = td;
+        }
+        applyExpose(meta, options);
+        // ── exclude ──
+        if (options.exclude) {
+            if (options.exclude === true) {
+                meta.exclude = {};
+            }
+            else if (options.exclude === 'deserializeOnly') {
+                meta.exclude = { deserializeOnly: true };
+            }
+            else if (options.exclude === 'serializeOnly') {
+                meta.exclude = { serializeOnly: true };
+            }
+        }
+        applyTransform(meta, propertyKey, options);
+    };
+}
+export { arrayOf, Field };

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

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

package/dist/src/decorators/index.js

@@ -1,2 +1,2 @@
-// @bun
-import"../../index-xdn55cz3.js";import{b as a,c as b}from"../../index-k3d659ad.js";import"../../index-fnv35wrf.js";import"../../index-s0n74vx1.js";export{a as arrayOf,b as Field};
+export { Field, arrayOf } from './field.js';
+export { Recipe } from './recipe.js';

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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1,23 @@
+import { globalRegistry } from '../registry.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// @Recipe — class decorator that registers a DTO for argless seal()
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 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();
+ * ```
+ */
+function Recipe(value, _context) {
+    globalRegistry.add(value);
+}
+export { Recipe };

package/dist/src/errors.d.ts

@@ -9,9 +9,9 @@
  * - 'conversionFailed': when type conversion fails in enableImplicitConversion
  * - 'whitelistViolation': when undeclared fields exist in input with whitelist: true
  *
- * Future extension fields (message, expected, actual, etc.) must be added as Optional.
+ * Future extension fields (expected, actual, etc.) must be added as Optional.
  */
-export interface BakerError {
+export interface BakerIssue {
     readonly path: string;
     readonly code: string;
     /** User-defined error message — included only when the decorator message option is set */
@@ -19,32 +19,43 @@ export interface BakerError {
     /** User-defined context — included only when the decorator context option is set */
     readonly context?: unknown;
 }
-/** Symbol tag for isBakerError() type guard — collision-proof discriminator */
+/** Symbol tag for isBakerIssueSet() type guard — collision-proof discriminator */
 export declare const BAKER_ERROR: unique symbol;
-/** Validation failure — returned by deserialize() on invalid input */
-export interface BakerErrors {
+/** Validation failure — returned by deserialize()/validate() on invalid input */
+export interface BakerIssueSet {
     readonly [BAKER_ERROR]: true;
-    readonly errors: readonly BakerError[];
+    readonly errors: readonly BakerIssue[];
 }
 /**
- * Type guard — narrows deserialize() result to BakerErrors.
+ * Type guard — narrows deserialize()/validate() result to BakerIssueSet.
  *
  * @example
  * const result = await deserialize(UserDto, input);
- * if (isBakerError(result)) {
- *   result.errors // readonly BakerError[]
+ * if (isBakerIssueSet(result)) {
+ *   result.errors // readonly BakerIssue[]
  * } else {
  *   result // UserDto
  * }
  */
-export declare function isBakerError(value: unknown): value is BakerErrors;
-/** @internal — create BakerErrors object */
-export declare function _toBakerErrors(errors: BakerError[]): BakerErrors;
+export declare function isBakerIssueSet(value: unknown): value is BakerIssueSet;
+/** @internal — create BakerIssueSet object */
+export declare function toBakerIssueSet(errors: BakerIssue[]): BakerIssueSet;
 /**
- * Seal-related error:
- * - When seal() is called more than once
- * - When deserialize()/serialize() is called on an unsealed class
+ * The single error thrown by baker for any developer/config/schema misuse — i.e. anything
+ * discoverable without external input. End-user input-data failures are NOT thrown; they are
+ * returned as a {@link BakerIssueSet}.
+ *
+ * Thrown when, e.g.:
+ * - deserialize()/serialize()/validate() is called on an unsealed class
+ * - configure() is called after seal(), or with an unknown key
+ * - 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
+ * - a user @Type/collectionValue thunk throws (wrapped, with the original error as `cause`)
+ * - an optional peer dependency (luxon/moment) is missing
  */
-export declare class SealError extends Error {
-    constructor(message: string);
+export declare class BakerError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }