@zipbul/baker 2.2.0 → 3.0.1

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{m as a,n as b}from"../../index-03cysbck.js";import"../../index-jp2yjd6g.js";import"../../index-mw7met6r.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,33 +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()/validate() on invalid input */
-export interface BakerErrors {
+export interface BakerIssueSet {
     readonly [BAKER_ERROR]: true;
-    readonly errors: readonly BakerError[];
+    readonly errors: readonly BakerIssue[];
 }
 /**
- * Type guard — narrows deserialize()/validate() 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()/validate() is called on an unsealed class
- * - When configure() is called after auto-seal
+ * 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;
+    });
 }

package/dist/src/errors.js

@@ -0,0 +1,52 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// BakerIssue — Individual field error (§12.2)
+// ─────────────────────────────────────────────────────────────────────────────
+// ─────────────────────────────────────────────────────────────────────────────
+// BakerIssueSet — Validation failure return (§12.2)
+// ─────────────────────────────────────────────────────────────────────────────
+/** Symbol tag for isBakerIssueSet() type guard — collision-proof discriminator */
+export const BAKER_ERROR = Symbol.for('baker:error');
+/**
+ * Type guard — narrows deserialize()/validate() result to BakerIssueSet.
+ *
+ * @example
+ * const result = await deserialize(UserDto, input);
+ * if (isBakerIssueSet(result)) {
+ *   result.errors // readonly BakerIssue[]
+ * } else {
+ *   result // UserDto
+ * }
+ */
+export function isBakerIssueSet(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        value[BAKER_ERROR] === true);
+}
+/** @internal — create BakerIssueSet object */
+export function toBakerIssueSet(errors) {
+    return { [BAKER_ERROR]: true, errors };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// BakerError — the single throw channel (§12.2)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 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 class BakerError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'BakerError';
+    }
+}

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

@@ -0,0 +1,8 @@
+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({...})"
+ *   - any other key → "unknown call option"
+ */
+export declare function checkCallOptions(opts: unknown): RuntimeOptions | undefined;

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

@@ -0,0 +1,51 @@
+import { BakerError } from '../errors.js';
+const CALL_OPTION_KEYS = new Set(['groups']);
+const SEAL_TIME_KEYS = new Set([
+    // BakerConfig (public, configure-time)
+    'autoConvert',
+    'allowClassDefaults',
+    'stopAtFirstError',
+    'forbidUnknown',
+    'debug',
+    // SealOptions (internal, legacy aliases — same set covered by public names)
+    'enableImplicitConversion',
+    'exposeDefaultValues',
+    'whitelist',
+]);
+/**
+ * @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({...})"
+ *   - any other key → "unknown call option"
+ */
+export function checkCallOptions(opts) {
+    if (opts === undefined || opts === null) {
+        return undefined;
+    }
+    if (typeof opts !== 'object' || Array.isArray(opts)) {
+        throw new BakerError(`Call options must be a plain object. Received: ${Array.isArray(opts) ? 'array' : typeof opts}.`);
+    }
+    // Strict same-realm plain-object check.
+    // Accept: `{}` (proto === Object.prototype) and `Object.create(null)` (proto === null).
+    // Reject: every other prototype, including class instances whose `constructor.name` is
+    // renamed to 'Object' (trojan), built-ins (Date/Map/Set), cross-realm objects.
+    // Cross-realm consumers can normalize with `Object.assign({}, opts)` before calling.
+    const proto = Object.getPrototypeOf(opts);
+    if (proto !== null && proto !== Object.prototype) {
+        const ctorName = opts.constructor?.name ?? 'unknown';
+        throw new BakerError(`Call options must be a plain object literal. Received instance of ${ctorName}.`);
+    }
+    for (const key of Object.keys(opts)) {
+        if (CALL_OPTION_KEYS.has(key)) {
+            continue;
+        }
+        if (SEAL_TIME_KEYS.has(key)) {
+            throw new BakerError(`Option '${key}' is a seal-time setting and cannot be passed per-call. ` +
+                `Move it to configure({ ${key}: ... }) at app startup. ` +
+                `Per-call options: ${[...CALL_OPTION_KEYS].join(', ')}.`);
+        }
+        throw new BakerError(`Unknown per-call option '${key}'. Valid per-call options: ${[...CALL_OPTION_KEYS].join(', ')}. ` +
+            `Seal-time options go to configure({...}).`);
+    }
+    return opts;
+}

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

@@ -1,12 +1,19 @@
-import { type BakerErrors } from '../errors';
 import type { RuntimeOptions } from '../interfaces';
+import { type BakerIssueSet } from '../errors';
 /**
  * Converts input to a Class instance + validates.
- * - Auto-seals on first call (batches entire globalRegistry)
+ * - Requires `seal()` to be called beforehand; throws `BakerError` if not sealed
  * - Sync DTOs return directly; async DTOs return Promise
  * - Success: T
- * - Validation failure: BakerErrors (use isBakerError() to narrow)
- * - Class without decorators: throws SealError
+ * - Validation failure: BakerIssueSet (use isBakerIssueSet() to narrow)
  */
-export declare function deserialize<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): T | BakerErrors;
-export declare function deserialize<T>(Class: new (...args: any[]) => T, input: unknown, options?: RuntimeOptions): Promise<T | BakerErrors>;
+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>;

package/dist/src/functions/deserialize.js

@@ -0,0 +1,57 @@
+import { isErr } from '@zipbul/result';
+import { toBakerIssueSet, BakerError } from '../errors.js';
+import { ensureSealed } from '../seal/seal.js';
+import { checkCallOptions } from './check-call-options.js';
+export function deserialize(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        return sealed.deserialize(input, checkedOpts).then((result) => {
+            if (isErr(result)) {
+                return toBakerIssueSet(result.data);
+            }
+            return result;
+        });
+    }
+    const result = sealed.deserialize(input, checkedOpts);
+    if (isErr(result)) {
+        return toBakerIssueSet(result.data);
+    }
+    return result;
+}
+/**
+ * Sync-asserted deserialize. Throws `BakerError` if Class has any async rule/transform
+ * on the deserialize side.
+ */
+export function deserializeSync(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        throw new BakerError(`deserializeSync(${Class.name}): DTO has async rules/transforms. Use deserializeAsync() instead.`);
+    }
+    const result = sealed.deserialize(input, checkedOpts);
+    if (isErr(result)) {
+        return toBakerIssueSet(result.data);
+    }
+    return result;
+}
+/**
+ * Async-asserted deserialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
+ */
+export function deserializeAsync(Class, input, options) {
+    const checkedOpts = checkCallOptions(options);
+    const sealed = ensureSealed(Class);
+    if (sealed.isAsync) {
+        return sealed.deserialize(input, checkedOpts).then((result) => {
+            if (isErr(result)) {
+                return toBakerIssueSet(result.data);
+            }
+            return result;
+        });
+    }
+    const result = sealed.deserialize(input, checkedOpts);
+    if (isErr(result)) {
+        return Promise.resolve(toBakerIssueSet(result.data));
+    }
+    return Promise.resolve(result);
+}