@zipbul/baker 3.4.0 → 3.4.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @zipbul/baker
 
+## 3.4.1
+
+### Patch Changes
+
+- 2df319e: Fix `arrayOf` emitting a duplicate `isArray` issue per element rule. When a non-collection value was
+  passed to a field carrying multiple element rules, each rule pushed its own `isArray` failure, so the
+  result held N identical issues instead of one. The collection-kind dispatch and the non-collection
+  rejection are now computed once at the field level, so a non-array/`Set`/`Map` value reports a single
+  `isArray` issue regardless of how many element rules the field declares. `validate(...)` and
+  `deserialize(...)` also now agree on the reported path for inlined nested DTOs.
+
+  Internal: the published library is now built with `bun build --no-bundle` (per-file ESM, import graph
+  preserved for consumer tree-shaking, full production minify) plus `tsc` for declarations. No public API
+  or runtime-behavior change — the dist is functionally identical, just smaller.
+
 ## 3.4.0
 
 ### Minor Changes

package/dist/index.js

@@ -1,10 +1 @@
-// Public API — Core
-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';
-// Decorators
-export { Field, arrayOf, Recipe } from './src/decorators/index.js';
-export { isBakerIssueSet, BakerError } from './src/errors.js';
+export{deserialize,deserializeSync,deserializeAsync}from"./src/functions/deserialize.js";export{validate,validateSync,validateAsync}from"./src/functions/validate.js";export{serialize,serializeSync,serializeAsync}from"./src/functions/serialize.js";export{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{isBakerIssueSet,BakerError}from"./src/errors.js";

package/dist/src/collect.js

@@ -1,26 +1 @@
-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: {},
-    });
-}
+import{RAW as x}from"./symbols.js";export function ensureMeta(j,z){if(!Object.hasOwn(j,x))j[x]=Object.create(null);const B=j[x];return B[z]??={validation:[],transform:[],expose:[],exclude:null,type:null,flags:{}}}

package/dist/src/configure.js

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

package/dist/src/create-rule.js

@@ -1,41 +1 @@
-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;
-}
+import{BakerError as K}from"./errors.js";import{defineRuleMetadata as U}from"./rule-metadata.js";import{isAsyncFunction as V,isPromiseLike as W}from"./utils.js";export function createRule(b,Q){const z=typeof b==="string"?b:b.name,C=typeof b==="string"?Q:b.validate;if(typeof C!=="function")throw new K(`createRule(${z}): a validate function is required.`);const I=typeof b==="object"?b.constraints:void 0,J=typeof b==="object"?b.requiresType:void 0,D=V(C),j=function(H){const w=C(H);if(!D&&W(w))throw new K(`createRule(${z}): sync rule returned Promise. Declare the validator with async if it is asynchronous.`);return w};j.emit=function(H,w){const S=w.addRef(j);return`if(!(${D?"await ":""}refs[${S}](${H}))) ${w.fail(z)};`};const G={emit:j.emit,ruleName:z,isAsync:D};if(I!==void 0)G.constraints=I;if(J!==void 0)G.requiresType=J;U(j,G);return j}

package/dist/src/decorators/field.js

@@ -1,277 +1 @@
-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);
-        // Field-level message/context — stored regardless of rules so non-rule failures
-        // (type gate, required-missing, conversion, structural gates) and type-only fields
-        // can carry them, not just rule-body failures.
-        if (options.context !== undefined) {
-            meta.context = options.context;
-        }
-        if (options.message !== undefined) {
-            meta.message = options.message;
-        }
-        // ── 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 };
+import{ensureMeta as w}from"../collect.js";import{BakerError as X}from"../errors.js";import{isAsyncFunction as D,isPromiseLike as I}from"../utils.js";const V=Symbol.for("baker:arrayOf");function arrayOf(...q){return{rules:q,[V]:!0}}function $(q){return typeof q==="object"&&q!==null&&q[V]===!0}const L=new Set(["type","discriminator","keepDiscriminatorProperty","rules","optional","nullable","name","deserializeName","serializeName","exclude","groups","when","transform","message","context","mapValue","setValue"]);function h(q){if(typeof q==="function")return!1;if(typeof q!=="object"||q===null)return!1;if($(q))return!1;const C=Object.keys(q);if(C.length===0)return!0;return C.some((b)=>L.has(b))}function N(q,C,b){const J=b?`${C} ${b}`:C;if(typeof q==="function"){const Q=q;if(typeof Q.emit!=="function"||typeof Q.ruleName!=="string"){const G=Q.name?` Did you forget to call '${Q.name}()'? Factories must be invoked (e.g., '${Q.name}()'). Rule constants are passed directly (e.g., 'isString' without parentheses).`:" Use createRule() or import a rule from @zipbul/baker/rules.";throw new X(`@Field on ${J}: argument is not a baker rule.${G} Valid @Field forms: @Field(), @Field(rule, ...), @Field(options), @Field(rule, ..., options).`)}return}throw new X(`@Field on ${J}: expected a baker rule (function with .emit and .ruleName), got ${q===null?"null":typeof q}. Use createRule() or import a rule from @zipbul/baker/rules. Valid @Field forms: @Field(), @Field(rule, ...), @Field(options), @Field(rule, ..., options).`)}function P(q){if(q.length===0)return{rules:[],options:{}};if(q.length===1&&h(q[0])){const b=q[0];return{rules:b.rules??[],options:b}}const C=q[q.length-1];if(h(C)){const b=C;let J=q.slice(0,-1);if(b.rules)J=[...J,...b.rules];return{rules:J,options:b}}return{rules:q,options:{}}}function Y(q,C,b){for(const J of C)if($(J))for(const H of J.rules){const Q={rule:H,each:!0};if(b.groups!==void 0)Q.groups=b.groups;if(b.message!==void 0)Q.message=b.message;if(b.context!==void 0)Q.context=b.context;q.validation.push(Q)}else{const H={rule:J};if(b.groups!==void 0)H.groups=b.groups;if(b.message!==void 0)H.message=b.message;if(b.context!==void 0)H.context=b.context;q.validation.push(H)}}function j(q,C){if(C.name){const b={name:C.name};if(C.groups!==void 0)b.groups=C.groups;q.expose.push(b)}else if(C.deserializeName||C.serializeName){if(C.deserializeName){const b={name:C.deserializeName,deserializeOnly:!0};if(C.groups!==void 0)b.groups=C.groups;q.expose.push(b)}if(C.serializeName){const b={name:C.serializeName,serializeOnly:!0};if(C.groups!==void 0)b.groups=C.groups;q.expose.push(b)}}else if(C.groups)q.expose.push({groups:C.groups});else q.expose.push({})}function S(q,C,b){const J=D(b);return{fn:(Q)=>{const G=b(Q);if(!J&&I(G))throw new X(`@Field(${q}) ${C} transform returned Promise. Declare the transform with async if it is asynchronous.`);return G},isAsync:J}}function z(q,C,b){if(!b.transform)return;const J=Array.isArray(b.transform)?b.transform:[b.transform];for(const H of J){const Q=S(C,"deserialize",H.deserialize),G=S(C,"serialize",H.serialize);q.transform.push({fn:Q.fn,isAsync:Q.isAsync,options:{deserializeOnly:!0}},{fn:G.fn,isAsync:G.isAsync,options:{serializeOnly:!0}})}}function Field(...q){return(C,b)=>{if(b.static)throw new X("@Field cannot decorate static fields.");if(b.private)throw new X("@Field cannot decorate private fields.");if(typeof b.name==="symbol")throw new X("@Field: symbol property keys are not supported. Use a string property name.");const J=b.name,H=w(b.metadata,J),{rules:Q,options:G}=P(q);if(G.name&&(G.deserializeName||G.serializeName))throw new X(`@Field on ${J}: 'name' cannot be combined with 'deserializeName'/'serializeName'. Use one or the other.`);for(let U=0;U<Q.length;U++){const W=Q[U];if($(W))for(let Z=0;Z<W.rules.length;Z++)N(W.rules[Z],J,`arrayOf[${Z}]`);else N(W,J)}Y(H,Q,G);if(G.context!==void 0)H.context=G.context;if(G.message!==void 0)H.message=G.message;if(G.optional)H.flags.isOptional=!0;if(G.nullable)H.flags.isNullable=!0;if(G.when)H.flags.validateIf=G.when;if(G.type){const U={fn:G.type};if(G.discriminator!==void 0)U.discriminator=G.discriminator;if(G.keepDiscriminatorProperty!==void 0)U.keepDiscriminatorProperty=G.keepDiscriminatorProperty;const W=G.mapValue??G.setValue;if(W!==void 0)U.collectionValue=W;H.type=U}j(H,G);if(G.exclude){if(G.exclude===!0)H.exclude={};else if(G.exclude==="deserializeOnly")H.exclude={deserializeOnly:!0};else if(G.exclude==="serializeOnly")H.exclude={serializeOnly:!0}}z(H,J,G)}}export{arrayOf,Field};

package/dist/src/decorators/index.js

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

package/dist/src/decorators/recipe.js

@@ -1,23 +1 @@
-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 };
+import{globalRegistry as q}from"../registry.js";function Recipe(j,z){q.add(j)}export{Recipe};

package/dist/src/errors.js

@@ -1,52 +1 @@
-// ─────────────────────────────────────────────────────────────────────────────
-// 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';
-    }
-}
+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"}}

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

@@ -1,51 +1 @@
-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;
-}
+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}

package/dist/src/functions/deserialize.js

@@ -1,57 +1 @@
-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);
-}
+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)}