@zipbul/baker 3.4.1 → 4.0.0

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

@@ -0,0 +1,8 @@
+/** Null/undefined guard strategy selected per field from its optional/nullable/defined flags. */
+export declare enum GuardKey {
+    NullableOptional = "nullable+optional",
+    Nullable = "nullable",
+    Defined = "defined",
+    Optional = "optional",
+    Default = "default"
+}

package/dist/src/seal/enums.js

@@ -0,0 +1 @@
+export var GuardKey;((l)=>{l.NullableOptional="nullable+optional";l.Nullable="nullable";l.Defined="defined";l.Optional="optional";l.Default="default"})(GuardKey||={});

package/dist/src/seal/expose-validator.js

@@ -1 +1 @@
-import{BakerError as K}from"../errors.js";function validateExposeStacks(F,z){const C=z?`${z}.`:"";for(const[A,H]of Object.entries(F)){for(const q of H.expose){if(q.deserializeOnly&&q.serializeOnly)throw new K(`Invalid @Expose on field '${C}${A}': cannot have both deserializeOnly:true and serializeOnly:true on the same @Expose entry. Use separate @Expose decorators for each direction.`);if(q.name==="__proto__"||q.name==="constructor"||q.name==="prototype")throw new K(`Invalid @Field name on '${C}${A}': '${q.name}' is a reserved property name and cannot be used as a serialized key.`)}const I=H.expose.filter((q)=>!q.serializeOnly),J=H.expose.filter((q)=>!q.deserializeOnly);L(C+A,I,"deserialize");L(C+A,J,"serialize")}}function L(F,z,C){for(let A=0;A<z.length;A++)for(let H=A+1;H<z.length;H++){const I=z[A].groups??[],J=z[H].groups??[];if(Q(I,J)){const q=new Set(J),M=I.length===0?[]:I.filter((P)=>q.has(P));throw new K(`@Expose conflict on '${F}': 2 @Expose stacks with '${C}' direction and overlapping groups [${M.join(", ")}]. Each direction must have at most one @Expose per group set.`)}}}function Q(F,z){if(F.length===0&&z.length===0)return!0;if(F.length===0||z.length===0)return!1;return F.some((C)=>z.includes(C))}export{validateExposeStacks};
+import{Direction as L}from"../enums.js";import{BakerError as K}from"../errors.js";function validateExposeStacks(F,z){const C=z?`${z}.`:"";for(const[A,H]of Object.entries(F)){for(const q of H.expose){if(q.deserializeOnly&&q.serializeOnly)throw new K(`Invalid @Expose on field '${C}${A}': cannot have both deserializeOnly:true and serializeOnly:true on the same @Expose entry. Use separate @Expose decorators for each direction.`);if(q.name==="__proto__"||q.name==="constructor"||q.name==="prototype")throw new K(`Invalid @Field name on '${C}${A}': '${q.name}' is a reserved property name and cannot be used as a serialized key.`)}const I=H.expose.filter((q)=>!q.serializeOnly),J=H.expose.filter((q)=>!q.deserializeOnly);M(C+A,I,L.Deserialize);M(C+A,J,L.Serialize)}}function M(F,z,C){for(let A=0;A<z.length;A++)for(let H=A+1;H<z.length;H++){const I=z[A].groups??[],J=z[H].groups??[];if(R(I,J)){const q=new Set(J),P=I.length===0?[]:I.filter((Q)=>q.has(Q));throw new K(`@Expose conflict on '${F}': 2 @Expose stacks with '${C}' direction and overlapping groups [${P.join(", ")}]. Each direction must have at most one @Expose per group set.`)}}}function R(F,z){if(F.length===0&&z.length===0)return!0;if(F.length===0||z.length===0)return!1;return F.some((C)=>z.includes(C))}export{validateExposeStacks};

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

@@ -1,3 +1,4 @@
+import type { SealOptions } from '../interfaces';
 import type { RawClassMeta, SealedExecutors } from '../types';
 /** @internal Placeholder executor for circular dependency detection during seal */
 declare function circularPlaceholder(className: string): SealedExecutors<unknown>;
@@ -6,6 +7,19 @@ declare function circularPlaceholder(className: string): SealedExecutors<unknown
  * Throws if the class was never sealed. Users must call `seal()` at app startup.
  */
 declare function ensureSealed(Class: Function): SealedExecutors<unknown>;
+/**
+ * Seal every class in `registry` with `options`. Shared core of both the global default `seal()`
+ * and per-scope `createBaker().seal()`. Transactional: on any failure every class sealed by this
+ * call is rolled back. Clears `registry` on success.
+ *
+ * A class already sealed (e.g. a shared value-type DTO reached from another scope's roots) is
+ * reused as-is — class identity is the isolation boundary, so a shared class carries one sealed
+ * behaviour. Distinct classes stay fully isolated because each is sealed with its scope's options.
+ *
+ * @param track Optional set recording successfully-sealed classes. The default seal passes the
+ *              global `sealedClasses` so `unseal()` can restore them; instances pass nothing.
+ */
+declare function sealRegistry(registry: Set<Function>, options: SealOptions, track?: Set<Function>): void;
 /**
  * Seal a single class (and its nested DTOs). Not part of the public API — `seal()` (argless)
  * is the only public entry. Exposed via `__testing__.sealClass` so tests can seal one class in
@@ -39,5 +53,5 @@ declare const __testing__: {
     circularPlaceholder: typeof circularPlaceholder;
     sealClass: typeof sealOneClass;
 };
-export { ensureSealed, seal, mergeInheritance, __testing__ };
+export { ensureSealed, seal, sealRegistry, mergeInheritance, __testing__ };
 export { sealedClasses, resetForTesting } from './seal-state';

package/dist/src/seal/seal.js

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

package/dist/src/seal/serialize-builder.js

@@ -1,17 +1,17 @@
-import{BakerError as c}from"../errors.js";import{getSealed as A}from"../meta-access.js";import{sanitizeKey as p,buildGroupsHasExpr as E}from"./codegen-utils.js";const j={out:"__bk$out",fieldVal:"__bk$fv_",groups:"__bk$groups",group0:"__bk$group0",groupsSet:"__bk$groupsSet",setArr:"__bk$sa",setItem:"__bk$si",mapObj:"__bk$m",mapEntry:"__bk$me",serResult:"__bk$sr",outItem:"__bk$out_item",discArr:"__bk$da",discIdx:"__bk$di",nestedArr:"__bk$na",nestedIdx:"__bk$ni",nestedItem:"__bk$nitem"};function m(U,q){const L=q.find((R)=>R.serializeOnly&&R.name);if(L)return L.name;const M=q.find((R)=>!R.deserializeOnly&&!R.serializeOnly&&R.name);if(M)return M.name;return U}function y(U){let q=null;for(const L of U){if(L.deserializeOnly)continue;if(!L.groups||L.groups.length===0)return;if(q===null)q=new Set;for(const M of L.groups)q.add(M)}return q===null?void 0:[...q]}function x(U,q,L,M){if(L.length===0)return null;if(L.length===1){const Y=L[0],W=M.length;M.push(Y.fn);const Z=`refs[${W}]({value:${U},key:${JSON.stringify(q)},obj:instance})`;return Y.isAsync?`(await ${Z})`:Z}if(L.length===2){const Y=L[1],W=L[0],Z=M.length;M.push(Y.fn);const F=M.length;M.push(W.fn);const z=`refs[${Z}]({value:${U},key:${JSON.stringify(q)},obj:instance})`,Q=Y.isAsync?`(await ${z})`:z,_=`refs[${F}]({value:${Q},key:${JSON.stringify(q)},obj:instance})`;return W.isAsync?`(await ${_})`:_}let R=U;for(let Y=L.length-1;Y>=0;Y-=1){const W=L[Y],Z=M.length;M.push(W.fn);const F=`refs[${Z}]({value:${R},key:${JSON.stringify(q)},obj:instance})`;R=W.isAsync?`(await ${F})`:F}return R}function T(U,q,L,M){const R=x(U,q,L,M);return R?`
+import{CollectionType as c}from"../enums.js";import{BakerError as p}from"../errors.js";import{getSealed as A}from"../meta-access.js";import{sanitizeKey as E,buildGroupsHasExpr as m}from"./codegen-utils.js";const j={out:"__bk$out",fieldVal:"__bk$fv_",groups:"__bk$groups",group0:"__bk$group0",groupsSet:"__bk$groupsSet",setArr:"__bk$sa",setItem:"__bk$si",mapObj:"__bk$m",mapEntry:"__bk$me",serResult:"__bk$sr",outItem:"__bk$out_item",discArr:"__bk$da",discIdx:"__bk$di",nestedArr:"__bk$na",nestedIdx:"__bk$ni",nestedItem:"__bk$nitem"};function u(U,q){const L=q.find((R)=>R.serializeOnly&&R.name);if(L)return L.name;const M=q.find((R)=>!R.deserializeOnly&&!R.serializeOnly&&R.name);if(M)return M.name;return U}function y(U){let q=null;for(const L of U){if(L.deserializeOnly)continue;if(!L.groups||L.groups.length===0)return;if(q===null)q=new Set;for(const M of L.groups)q.add(M)}return q===null?void 0:[...q]}function x(U,q,L,M){if(L.length===0)return null;if(L.length===1){const Y=L[0],W=M.length;M.push(Y.fn);const Z=`refs[${W}]({value:${U},key:${JSON.stringify(q)},obj:instance})`;return Y.isAsync?`(await ${Z})`:Z}if(L.length===2){const Y=L[1],W=L[0],Z=M.length;M.push(Y.fn);const F=M.length;M.push(W.fn);const z=`refs[${Z}]({value:${U},key:${JSON.stringify(q)},obj:instance})`,Q=Y.isAsync?`(await ${z})`:z,_=`refs[${F}]({value:${Q},key:${JSON.stringify(q)},obj:instance})`;return W.isAsync?`(await ${_})`:_}let R=U;for(let Y=L.length-1;Y>=0;Y-=1){const W=L[Y],Z=M.length;M.push(W.fn);const F=`refs[${Z}]({value:${R},key:${JSON.stringify(q)},obj:instance})`;R=W.isAsync?`(await ${F})`:F}return R}function T(U,q,L,M){const R=x(U,q,L,M);return R?`
 ${U} = ${R};`:""}function buildSerializeCode(U,q,L,M){const R=[],Y=[];let W=`'use strict';
 `;W+=`var ${j.out} = {};
 `;if(Object.values(q).some((_)=>{const v=y(_.expose);return v&&v.length>0})){W+=`var ${j.groups} = opts && opts.groups;
 `;W+=`var ${j.group0} = ${j.groups} && ${j.groups}.length === 1 ? ${j.groups}[0] : null;
 `;W+=`var ${j.groupsSet} = ${j.groups} && ${j.groups}.length > 1 ? new Set(${j.groups}) : null;
-`}for(const[_,v]of Object.entries(q))W+=u(_,v,R,Y,M,L,U.name);W+=`return ${j.out};
+`}for(const[_,v]of Object.entries(q))W+=f(_,v,R,Y,M,L,U.name);W+=`return ${j.out};
 `;const F=U.name.replace(/[^\w$.-]/g,"_");W+=`//# sourceURL=baker://${F}/serialize
-`;return Function("refs","execs","BakerError",`return ${M?"async function":"function"}(instance, opts) { `+W+" }")(R,Y,c)}function u(U,q,L,M,R,Y,W=""){if(q.exclude){if(!q.exclude.deserializeOnly){if(Y?.debug){const X=q.exclude.serializeOnly?"serializeOnly":"bidirectional";return`// [baker] field ${JSON.stringify(U)} excluded (${X} @Exclude)
+`;return Function("refs","execs","BakerError",`return ${M?"async function":"function"}(instance, opts) { `+W+" }")(R,Y,p)}function f(U,q,L,M,R,Y,W=""){if(q.exclude){if(!q.exclude.deserializeOnly){if(Y?.debug){const X=q.exclude.serializeOnly?"serializeOnly":"bidirectional";return`// [baker] field ${JSON.stringify(U)} excluded (${X} @Exclude)
 `}return""}}if(q.expose.length>0&&q.expose.every((X)=>X.deserializeOnly)){if(Y?.debug)return`// [baker] field ${JSON.stringify(U)} excluded (all @Expose entries are deserializeOnly)
-`;return""}const Z=m(U,q.expose),F=y(q.expose),z=p(U),Q=`${j.fieldVal}${z}`;let _="";_+=`var ${Q} = instance[${JSON.stringify(U)}];
-`;let v="",S="";if(F&&F.length>0){v=`if ((${j.group0} !== null || ${j.groupsSet}) && (${E(j.group0,j.groupsSet,F)})) {
+`;return""}const Z=u(U,q.expose),F=y(q.expose),z=E(U),Q=`${j.fieldVal}${z}`;let _="";_+=`var ${Q} = instance[${JSON.stringify(U)}];
+`;let v="",S="";if(F&&F.length>0){v=`if ((${j.group0} !== null || ${j.groupsSet}) && (${m(j.group0,j.groupsSet,F)})) {
 `;S=`}
-`}let H="";const b=q.flags.isOptional,g=q.transform.filter((X)=>!X.options?.deserializeOnly);if(q.type?.collection){const X=`${j.out}[${JSON.stringify(Z)}]`,$=q.type.collection;let J;if($==="Set")if(q.type.resolvedCollectionValue){const B=A(q.type.resolvedCollectionValue),D=M.length;M.push(B);if(R)J=`{ var __ser_ps = []; for (var __ser_item of ${Q}) { __ser_ps.push(__ser_item == null ? __ser_item : execs[${D}].serialize(__ser_item, opts)); } ${X} = await Promise.all(__ser_ps); }`;else{J=`var ${j.setArr} = [];
+`}let H="";const b=q.flags.isOptional,g=q.transform.filter((X)=>!X.options?.deserializeOnly);if(q.type?.collection){const X=`${j.out}[${JSON.stringify(Z)}]`,$=q.type.collection;let J;if($===c.Set)if(q.type.resolvedCollectionValue){const B=A(q.type.resolvedCollectionValue),D=M.length;M.push(B);if(R)J=`{ var __ser_ps = []; for (var __ser_item of ${Q}) { __ser_ps.push(__ser_item == null ? __ser_item : execs[${D}].serialize(__ser_item, opts)); } ${X} = await Promise.all(__ser_ps); }`;else{J=`var ${j.setArr} = [];
 `;J+=`  for (var ${j.setItem} of ${Q}) {
 `;J+=`    ${j.setArr}.push(${j.setItem} == null ? ${j.setItem} : execs[${D}].serialize(${j.setItem}, opts));
 `;J+=`  }
@@ -63,8 +63,8 @@ ${U} = ${R};`:""}function buildSerializeCode(U,q,L,M){const R=[],Y=[];let W=`'us
 } else {
   ${$} = ${Q};
 }
-`}else{const X=f(U,Z,Q,q,L);if(b){H+=`if (${Q} !== undefined) {
+`}else{const X=n(U,Z,Q,q,L);if(b){H+=`if (${Q} !== undefined) {
 `;H+="  "+X+`
 `;H+=`}
 `}else H+=X+`
-`}_+=v+H+S;return _}function f(U,q,L,M,R){const Y=`${j.out}[${JSON.stringify(q)}]`,W=M.transform.filter((Z)=>!Z.options?.deserializeOnly);if(W.length>0){const Z=x(L,U,W,R);return`${Y} = ${Z};`}return`${Y} = ${L};`}export{buildSerializeCode};
+`}_+=v+H+S;return _}function n(U,q,L,M,R){const Y=`${j.out}[${JSON.stringify(q)}]`,W=M.transform.filter((Z)=>!Z.options?.deserializeOnly);if(W.length>0){const Z=x(L,U,W,R);return`${Y} = ${Z};`}return`${Y} = ${L};`}export{buildSerializeCode};

package/dist/src/seal/validate-meta.js

@@ -1 +1 @@
-import{BakerError as x}from"../errors.js";import{hasRawOwn as G}from"../meta-access.js";export function validateMeta(H,I){const p=H.name;for(const[q,A]of Object.entries(I)){if(A.type?.discriminator){const f=A.type.discriminator;if(typeof f.property!=="string"||f.property.length===0)throw new x(`${p}.${q}: discriminator.property must be a non-empty string.`);if(!Array.isArray(f.subTypes)||f.subTypes.length===0)throw new x(`${p}.${q}: discriminator.subTypes must be a non-empty array of { value, name } entries.`);const D=new Set;for(let z=0;z<f.subTypes.length;z++){const j=f.subTypes[z];if(typeof j.name!=="string"||j.name.length===0)throw new x(`${p}.${q}: discriminator.subTypes[${z}].name must be a non-empty string.`);if(typeof j.value!=="function")throw new x(`${p}.${q}: discriminator.subTypes[${z}].value must be a class constructor (got ${typeof j.value}).`);if(D.has(j.name))throw new x(`${p}.${q}: discriminator.subTypes has duplicate name '${j.name}'. Each subType must have a unique name.`);D.add(j.name);if(!G(j.value))throw new x(`${p}.${q}: discriminator.subTypes[${z}].value (${j.value.name}) has no @Field decorators.`)}}const F=A.type?.collection;if(F!==void 0&&A.type?.resolvedCollectionValue){const f=A.type.resolvedCollectionValue;if(!G(f))throw new x(`${p}.${q}: ${F==="Set"?"setValue":"mapValue"} target (${f.name}) has no @Field decorators.`)}}}
+import{CollectionType as K}from"../enums.js";import{BakerError as z}from"../errors.js";import{hasRawOwn as H}from"../meta-access.js";export function validateMeta(I,J){const q=I.name;for(const[x,D]of Object.entries(J)){if(D.type?.discriminator){const f=D.type.discriminator;if(typeof f.property!=="string"||f.property.length===0)throw new z(`${q}.${x}: discriminator.property must be a non-empty string.`);if(!Array.isArray(f.subTypes)||f.subTypes.length===0)throw new z(`${q}.${x}: discriminator.subTypes must be a non-empty array of { value, name } entries.`);const F=new Set;for(let A=0;A<f.subTypes.length;A++){const j=f.subTypes[A];if(typeof j.name!=="string"||j.name.length===0)throw new z(`${q}.${x}: discriminator.subTypes[${A}].name must be a non-empty string.`);if(typeof j.value!=="function")throw new z(`${q}.${x}: discriminator.subTypes[${A}].value must be a class constructor (got ${typeof j.value}).`);if(F.has(j.name))throw new z(`${q}.${x}: discriminator.subTypes has duplicate name '${j.name}'. Each subType must have a unique name.`);F.add(j.name);if(!H(j.value))throw new z(`${q}.${x}: discriminator.subTypes[${A}].value (${j.value.name}) has no @Field decorators.`)}}const G=D.type?.collection;if(G!==void 0&&D.type?.resolvedCollectionValue){const f=D.type.resolvedCollectionValue;if(!H(f)){const F=G===K.Set?"setValue":"mapValue";throw new z(`${q}.${x}: ${F} target (${f.name}) has no @Field decorators.`)}}}}

package/dist/src/types.d.ts

@@ -1,4 +1,5 @@
 import type { Result, ResultAsync } from '@zipbul/result';
+import type { CacheKey, CollectionType, RequiredType, RuleOp, RulePlanCheckKind, RulePlanExprKind } from './enums';
 import type { BakerIssue } from './errors';
 import type { RuntimeOptions } from './interfaces';
 export interface EmitContext {
@@ -26,7 +27,7 @@ export interface EmittableRule {
      * Only set for rules that assume a specific type (e.g., isEmail → 'string').
      * `@IsString` itself is undefined (it includes its own typeof check).
      */
-    readonly requiresType?: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+    readonly requiresType?: RequiredType;
     /** Expose rule parameters for external reading */
     readonly constraints?: Record<string, unknown>;
     /** true when the rule is explicitly async and must be awaited */
@@ -37,30 +38,30 @@ export interface InternalRule extends EmittableRule {
     readonly plan?: RulePlan;
 }
 export type RulePlanExpr = {
-    kind: 'value';
+    kind: RulePlanExprKind.Value;
 } | {
-    kind: 'member';
+    kind: RulePlanExprKind.Member;
     object: RulePlanExpr;
     property: 'length';
 } | {
-    kind: 'call0';
+    kind: RulePlanExprKind.Call0;
     object: RulePlanExpr;
     method: 'getTime';
 } | {
-    kind: 'literal';
+    kind: RulePlanExprKind.Literal;
     value: number;
 };
 export type RulePlanCheck = {
-    kind: 'compare';
+    kind: RulePlanCheckKind.Compare;
     left: RulePlanExpr;
-    op: '<' | '<=' | '>' | '>=' | '===' | '!==';
+    op: RuleOp;
     right: RulePlanExpr;
 } | {
-    kind: 'and' | 'or';
+    kind: RulePlanCheckKind.And | RulePlanCheckKind.Or;
     checks: RulePlanCheck[];
 };
 export interface RulePlan {
-    cacheKey?: 'length' | 'time';
+    cacheKey?: CacheKey;
     failure: RulePlanCheck;
 }
 /** Arguments for user-defined message callback */
@@ -125,7 +126,7 @@ export interface TypeDef {
     /** seal() normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
     resolvedClass?: ClassCtor;
     /** seal() normalization result — Map or Set collection type */
-    collection?: 'Map' | 'Set';
+    collection?: CollectionType;
     /** Nested DTO class thunk for Map value / Set element */
     collectionValue?: () => ClassCtor;
     /** seal() normalization result — cached class after resolving collectionValue */

package/package.json

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