@zipbul/baker 5.1.0 → 5.2.0

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

@@ -0,0 +1,58 @@
+import type { RawPropertyMeta, RuleDef } from '../metadata';
+import type { EmitContext } from '../rules';
+import type { CategorizedRules } from './interfaces';
+import { GuardKey } from './enums';
+/** Generate nested error push code that propagates message/context fields */
+export declare function nestedErrPush(errList: string, pathExpr: string, errItemExpr: string, tmpVar: string): string;
+/** Generate nested error return code that propagates message/context fields */
+export declare function nestedErrReturn(pathExpr: string, errItemExpr: string, tmpVar: string, validateOnly?: boolean): string;
+/** Convert field name to a safe JS variable name (includes prefix to prevent internal variable collisions) */
+export declare function toVarName(key: string, prefix?: string): string;
+export declare function resolveGuardKey(isNullable: boolean, useOptionalGuard: boolean): GuardKey;
+export interface GuardParams {
+    varName: string;
+    emitCtx: EmitContext;
+    assignNull: string;
+    validationCode: string;
+}
+export declare const GUARD_STRATEGIES: Record<GuardKey, (p: GuardParams) => string>;
+/**
+ * When rd.groups is set, only execute code if there is an intersection with runtime __bk$groups.
+ * Rules without groups always execute (preserves existing behavior).
+ */
+export declare function wrapGroupsGuard(rd: RuleDef, code: string): string;
+export declare function sameGroups(a?: string[], b?: string[]): boolean;
+export declare function generateConversionCode(targetType: string, varName: string, fieldKey: string, skipVar: string | null, // null = stopAtFirstError
+collectErrors: boolean, emitCtx: EmitContext): string;
+/** Result of categorizeRules — each/nonEach split and typed dependency classification */
+/** categorizeRules — separate each/nonEach rules, detect mixed gate conflicts (pure) */
+export declare function categorizeRules(fieldKey: string, validation: RawPropertyMeta['validation']): CategorizedRules;
+/** Config object for emitTypedRules — bundles closure-captured vars into explicit parameter */
+export interface TypeGateConfig {
+    effectiveGateType: string;
+    gateCondition: string;
+    gateErrorCode: string;
+    gateEmitCtx: EmitContext;
+    otherGeneral: RuleDef[];
+    gateDeps: RuleDef[];
+    typeAsserter: RuleDef | undefined;
+    enableConversion: boolean;
+}
+/** Generate nested-result handling for deserialize mode (pure) */
+export declare function generateNestedResultCode(fieldKey: string, resultVar: string, collectErrors: boolean, pathPrefix?: string): string;
+/**
+ * Nested-executor result handling inside a per-element loop (Set / Map / array / discriminator-each).
+ * Single source for the `if (isErr(result)) { …re-path nested errors… } else { <success> }` block that
+ * every collection loop repeats — only the element path expression (`ppExpr`), the success statement
+ * (`arr.push` / `map.set` / `set.add`), and the base indent differ. The single-object case keeps using
+ * {@link generateNestedResultCode} (it writes straight to `out[field]`).
+ */
+export declare function generateNestedEachResultCode(resultVar: string, ppExpr: string, sk: string, collectErrors: boolean, successStmt: string, indent: string): string;
+/** Generate validate-mode nested result handling (null check instead of isErr) (pure) */
+export declare function generateValidateNestedResult(fieldKey: string, resultVar: string, collectErrors: boolean, pathPrefix?: string): string;
+/**
+ * Validate-mode counterpart of {@link generateNestedEachResultCode}: the per-element `if (result !==
+ * null) { …re-path the returned issue array… }` block shared by the Set / Map / array / discriminator
+ * validate-each loops. The element path expression and base indent are the only per-site differences.
+ */
+export declare function generateValidateNestedEachResultCode(resultVar: string, ppExpr: string, sk: string, collectErrors: boolean, indent: string): string;

package/dist/src/seal/deserialize-codegen.js

@@ -0,0 +1,64 @@
+import{BakerError as M}from"../common/index.js";import{sanitizeKey as H,buildGroupsHasExpr as q}from"./codegen-utils.js";import{DES_GEN as W}from"./constants.js";import{GuardKey as Z}from"./enums.js";export function nestedErrPush(w,j,D,Q){const A=`${Q}_e`;return`var ${A}=${D};
+      if(${A}.message===undefined&&${A}.context===undefined){${w}.push({path:${j},code:${A}.code});}
+      else{var ${Q}={path:${j},code:${A}.code};
+      if(${A}.message!==undefined)${Q}.message=${A}.message;
+      if(${A}.context!==undefined)${Q}.context=${A}.context;
+      ${w}.push(${Q});}
+`}export function nestedErrReturn(w,j,D,Q){const A=(U)=>Q?`return ${U};
+`:`return err(${U});
+`,J=`${D}_e`;return`var ${J}=${j};
+    if(${J}.message===undefined&&${J}.context===undefined)${A(`[{path:${w},code:${J}.code}]`)}    var ${D}={path:${w},code:${J}.code};
+    if(${J}.message!==undefined)${D}.message=${J}.message;
+    if(${J}.context!==undefined)${D}.context=${J}.context;
+    ${A(`[${D}]`)}`}export function toVarName(w,j){return W.field+(j||"")+H(w)}export function resolveGuardKey(w,j){if(w&&j)return Z.NullableOptional;if(w)return Z.Nullable;if(j)return Z.Optional;return Z.Default}export const GUARD_STRATEGIES={[Z.NullableOptional]({varName:w,assignNull:j,validationCode:D}){let Q=`if (${w} === null) { ${j}}
+`;Q+=`else if (${w} !== undefined) {
+`;Q+=D;Q+=`}
+`;return Q},[Z.Nullable]({varName:w,emitCtx:j,assignNull:D,validationCode:Q}){let A=`if (${w} === undefined) ${j.fail("isDefined")};
+`;A+=`else if (${w} !== null) {
+`;A+=Q;A+=`} else { ${D}}
+`;return A},[Z.Optional]({varName:w,validationCode:j}){let D=`if (${w} !== undefined && ${w} !== null) {
+`;D+=j;D+=`}
+`;return D},[Z.Default]({varName:w,emitCtx:j,validationCode:D}){let Q=`if (${w} === undefined || ${w} === null) ${j.fail("isDefined")};
+`;Q+=`else {
+`;Q+=D;Q+=`}
+`;return Q}};export function wrapGroupsGuard(w,j){if(!w.groups||w.groups.length===0)return j;return`if ((${W.group0} === null && !${W.groupsSet}) || ${q(W.group0,W.groupsSet,w.groups)}) {
+${j}
+}
+`}export function sameGroups(w,j){if(!w||w.length===0)return!j||j.length===0;if(!j||w.length!==j.length)return!1;for(let D=0;D<w.length;D++)if(w[D]!==j[D])return!1;return!0}export function generateConversionCode(w,j,D,Q,A,J){const U=A?`${J.fail("conversionFailed")}; ${Q} = true;`:J.fail("conversionFailed")+";";switch(w){case"string":return`  ${j} = String(${j});
+`;case"number":return`  ${j} = Number(${j});
+  if (isNaN(${j})) { ${U} }
+`;case"boolean":return`  if (${j} === 'true' || ${j} === '1' || ${j} === 1) ${j} = true;
+  else if (${j} === 'false' || ${j} === '0' || ${j} === 0) ${j} = false;
+  else { ${U} }
+`;case"date":return`  ${j} = new Date(${j});
+  if (isNaN(${j}.getTime())) { ${U} }
+`;default:throw new M(`Unknown implicit conversion type: "${w}" for field "${D}"`)}}export function categorizeRules(w,j){const D=[],Q=[],A={string:[],number:[],boolean:[],date:[],array:[],object:[]};for(const X of j){if(X.each){D.push(X);continue}const Y=X.rule.requiresType;if(Y!==void 0)A[Y].push(X);else Q.push(X)}let J=void 0,U=null;for(const X of["string","number","boolean","date","array","object"]){const Y=A[X];if(Y.length===0)continue;if(J){if(U===null)U=[J.type];U.push(X)}else J={type:X,deps:Y}}if(U)throw new M(`Field "${w}" has conflicting requiresType: ${U.join(", ")}`);return{each:D,generalRules:Q,typedDeps:J}}export function generateNestedResultCode(w,j,D,Q){const A=H(w),J=Q?`${Q}+${JSON.stringify(w+".")}`:JSON.stringify(w+".");if(D){const X=`${W.errors}${A}[${W.nestedIdx}${A}]`;return`  if (isErr(${j})) {
+    var ${W.errors}${A} = ${j}.data;
+    var __bk$pp${A} = ${J};
+    for (var ${W.nestedIdx}${A}=0; ${W.nestedIdx}${A}<${W.errors}${A}.length; ${W.nestedIdx}${A}++) {
+      `+nestedErrPush(W.errList,`__bk$pp${A}+${X}.path`,X,`__ne${A}`)+`    }
+  } else { ${W.out}[${JSON.stringify(w)}] = ${j}; }
+`}const U=`${W.errors}${A}[0]`;return`  if (isErr(${j})) {
+    var ${W.errors}${A} = ${j}.data;
+    var __bk$pp${A} = ${J};
+    `+nestedErrReturn(`__bk$pp${A}+${U}.path`,U,`__ne${A}`)+`  } else { ${W.out}[${JSON.stringify(w)}] = ${j}; }
+`}export function generateNestedEachResultCode(w,j,D,Q,A,J){const U=`${W.errors}${D}`,X=`__bk$pp${D}`,Y=`${J}  var ${U} = ${w}.data;
+${J}  var ${X} = ${j};
+`;let $;if(Q){const _=`${W.nestedIdx}${D}`;$=`${J}  for (var ${_}=0; ${_}<${U}.length; ${_}++) {
+${J}  `+nestedErrPush(W.errList,`${X}+${U}[${_}].path`,`${U}[${_}]`,`__ne${D}`)+`${J}  }
+`}else $=`${J}  `+nestedErrReturn(`${X}+${U}[0].path`,`${U}[0]`,`__ne${D}`);return`${J}if (isErr(${w})) {
+${Y}${$}${J}} else { ${A} }
+`}export function generateValidateNestedResult(w,j,D,Q){const A=H(w),J=`__bk$pp${A}`,U=Q?`${Q}+${JSON.stringify(w+".")}`:JSON.stringify(w+".");if(D){const Y=`${j}[${W.nestedIdx}${A}]`;return`  if (${j} !== null) {
+    var ${J} = ${U};
+    for (var ${W.nestedIdx}${A}=0; ${W.nestedIdx}${A}<${j}.length; ${W.nestedIdx}${A}++) {
+      `+nestedErrPush(W.errList,`${J}+${Y}.path`,Y,`__ne${A}`)+`    }
+  }
+`}const X=`${j}[0]`;return`  if (${j} !== null) {
+    var ${J} = ${U};
+    `+nestedErrReturn(`${J}+${X}.path`,X,`__ne${A}`,!0)+`  }
+`}export function generateValidateNestedEachResultCode(w,j,D,Q,A){const J=`__bk$pp${D}`;let U=`${A}if (${w} !== null) {
+${A}  var ${J} = ${j};
+`;if(Q){const X=`${W.nestedIdx}${D}`;U+=`${A}  for (var ${X}=0; ${X}<${w}.length; ${X}++) {
+${A}  `+nestedErrPush(W.errList,`${J}+${w}[${X}].path`,`${w}[${X}]`,`__ne${D}`)+`${A}  }
+`}else U+=`${A}  `+nestedErrReturn(`${J}+${w}[0].path`,`${w}[0]`,`__ne${D}`,!0);U+=`${A}}
+`;return U}

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

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

package/dist/src/seal/enums.js

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

package/dist/src/seal/expose-validator.d.ts

@@ -1,6 +1,6 @@
-import type { RawClassMeta } from '../types';
+import type { RawClassMeta } from '../metadata';
 /**
- * Static validation of @Expose stacks (§4.1, §3.3)
+ * Static validation of @Expose stacks
  *
  * Check 1: same @Expose entry has deserializeOnly: true + serializeOnly: true → excluded from both directions
  * Check 2: if 2+ @Expose entries in the same direction have overlapping groups → BakerError

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

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

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

@@ -0,0 +1,3 @@
+export type { SealedExecutors, SealOptions } from './interfaces';
+export { sealRegistry } from './seal';
+export { SEAL_OPTION_KEYS } from './constants';

package/dist/src/seal/index.js

@@ -0,0 +1 @@
+export{sealRegistry}from"./seal.js";export{SEAL_OPTION_KEYS}from"./constants.js";

package/dist/src/seal/inheritance-merger.d.ts

@@ -0,0 +1,18 @@
+import type { RawClassMeta, MetaStore } from '../metadata';
+/**
+ * Merges RAW metadata child-first along the prototype chain of a class. Holds the {@link MetaStore} it
+ * reads RAW through as an injected collaborator.
+ *
+ * Merge rules:
+ * - validation: union by ruleName — child wins on a same-ruleName collision; otherwise parent rules are appended
+ * - transform: child takes priority, inherits from parent if absent in child
+ * - expose: child takes priority, inherits from parent if absent in child
+ * - exclude: child takes priority, inherits from parent if absent in child
+ * - type: child takes priority, inherits from parent if absent in child
+ * - flags: child takes priority, only missing flags are supplemented from parent
+ */
+export declare class InheritanceMerger {
+    #private;
+    constructor(meta: MetaStore);
+    merge(Class: Function): RawClassMeta;
+}

package/dist/src/seal/inheritance-merger.js

@@ -0,0 +1 @@
+export class InheritanceMerger{#b;constructor(D){this.#b=D}merge(D){const F=[];let z=D;while(z&&z!==Object){if(this.#b.hasOwn(z))F.push(z);const B=Object.getPrototypeOf(z);z=B===z?null:B}const A=Object.create(null);for(const B of F){const H=this.#b.get(B);for(const[E,x]of Object.entries(H))if(!A[E])A[E]={...x,validation:[...x.validation],transform:[...x.transform],expose:[...x.expose],exclude:x.exclude,type:x.type,flags:{...x.flags}};else{const b=A[E],j=x;for(const G of j.validation)if(!b.validation.some((I)=>I.rule.ruleName===G.rule.ruleName))b.validation.push(G);if(b.transform.length===0&&j.transform.length>0)b.transform=[...j.transform];if(b.expose.length===0&&j.expose.length>0)b.expose=[...j.expose];if(b.exclude===null&&j.exclude!==null)b.exclude=j.exclude;if(b.type===null&&j.type!==null)b.type=j.type;if(b.message===void 0&&j.message!==void 0)b.message=j.message;if(b.context===void 0&&j.context!==void 0)b.context=j.context;const q=b.flags,v=j.flags;if(v.isOptional!==void 0&&q.isOptional===void 0)q.isOptional=v.isOptional;if(v.validateIf!==void 0&&q.validateIf===void 0)q.validateIf=v.validateIf;if(v.isNullable!==void 0&&q.isNullable===void 0)q.isNullable=v.isNullable;if(v.validateNested!==void 0&&q.validateNested===void 0)q.validateNested=v.validateNested;if(v.validateNestedEach!==void 0&&q.validateNestedEach===void 0)q.validateNestedEach=v.validateNestedEach}}return A}}

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

@@ -0,0 +1,89 @@
+import type { Result, ResultAsync } from '@zipbul/result';
+import type { BakerIssue, RuntimeOptions } from '../common';
+import type { CollectionType, RawClassMeta, RuleDef } from '../metadata';
+export interface SealOptions {
+    /** Automatic conversion using validation decorators as type hints. @default false */
+    enableImplicitConversion?: boolean;
+    /** Use class default values when the key is missing from input. @default false */
+    exposeDefaultValues?: boolean;
+    /** true: return immediately on first error. false (default): collect all errors. @default false */
+    stopAtFirstError?: boolean;
+    /**
+     * true: reject undeclared fields. Uses the key set from mergeInheritance(Class) as the allowlist.
+     * `@Exclude` fields are also included in the whitelist — present but excluded from the result.
+     * @default false
+     */
+    whitelist?: boolean;
+    /** true: include field exclusion reasons as comments in generated code. @default false */
+    debug?: boolean;
+}
+export interface SealedExecutors<T> {
+    /** Internal executor — Result pattern. deserialize() wraps and converts to throw */
+    deserialize(input: unknown, options?: RuntimeOptions): Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
+    /** Internal executor — always succeeds. serialize assumes no validation */
+    serialize(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Internal executor — validate-only (no object creation). Returns null on success, BakerIssue[] on failure */
+    validate(input: unknown, options?: RuntimeOptions): BakerIssue[] | null | Promise<BakerIssue[] | null>;
+    /** true if the deserialize direction has async rules/transforms/nested */
+    isAsync: boolean;
+    /** true if the serialize direction has async transforms/nested */
+    isSerializeAsync: boolean;
+    /** Inheritance-resolved metadata — read during codegen to wire nested DTO fields and async analysis */
+    merged?: RawClassMeta;
+}
+/**
+ * Classification of a `@Type`/`@Field` `type` thunk's return value. The single reading of the
+ * Map/Set marker + array-unwrap that seal normalization, circular analysis, and async analysis all
+ * share — each caller then applies its OWN primitive-exclusion and error policy to `resolved` (seal
+ * throws on a non-constructor; the analyzers skip it), so only the classification lives here.
+ */
+export interface ClassifiedType {
+    /** Set when the thunk returned the `Map` or `Set` constructor (a collection field). */
+    collection?: CollectionType;
+    /** True when the thunk returned the array form `[Element]`. */
+    isArray: boolean;
+    /** The element value (array-unwrapped), or `undefined` for a Map/Set collection. */
+    resolved: unknown;
+}
+/**
+ * Inline-nested scope a parent builder hands to a child: the shared mutable accumulator (reference
+ * arrays + circular-tracking set) plus the child's own path/var/input expression overrides.
+ */
+export interface ChildScope {
+    regexes: RegExp[];
+    refs: unknown[];
+    execs: SealedExecutors<unknown>[];
+    inlineCounter: {
+        n: number;
+    };
+    inlineNestedClasses: Set<Function> | undefined;
+    pathPrefix: string;
+    varPrefix: string;
+    inputExpr: string;
+}
+/** Partitioned validation rules for a field — produced by categorizeRules. */
+export interface CategorizedRules {
+    each: RuleDef[];
+    generalRules: RuleDef[];
+    /** The single typed dependency group (if any) after conflict check */
+    typedDeps: {
+        type: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+        deps: RuleDef[];
+    } | undefined;
+}
+/** Result of resolveTypeGate — effective gate type and related metadata. */
+export interface ResolvedTypeGate {
+    effectiveGateType: string | null;
+    /** The typed dependency rules (from requiresType) */
+    gateDeps: RuleDef[];
+    /** Index of the type asserter within generalRules (-1 if none) */
+    typeAsserterIdx: number;
+    /** The type asserter rule def (if found) */
+    typeAsserter: RuleDef | undefined;
+    /** Whether conversion is enabled for this field */
+    enableConversion: boolean;
+    /** Whether this gate was inferred from asserter only (no typed deps) */
+    asserterInferredGate: string | null;
+    /** Whether this gate was inferred from @Type hint */
+    typeHintGate: string | null;
+}

package/dist/src/seal/meta-validator.d.ts

@@ -0,0 +1,16 @@
+import type { RawClassMeta, MetaStore } from '../metadata';
+/**
+ * Seal-time invariant checks on the merged metadata, run from sealOne after merge + type normalization
+ * and before codegen. Holds the {@link MetaStore} (for @Field-presence checks) as an injected collaborator.
+ * Throws BakerError on the first violation.
+ *
+ * Covers W2 (D7 + D9):
+ * - Discriminator shape: empty subTypes / invalid subType entry / name collision / missing/reserved property
+ * - Set/Map pairing: when a setValue/mapValue thunk is present, its target class must have @Field metadata
+ *   (a primitive Set/Map with no value thunk is valid and intentionally not flagged)
+ */
+export declare class MetaValidator {
+    #private;
+    constructor(meta: MetaStore);
+    validateShape(Class: Function, merged: RawClassMeta): void;
+}

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

@@ -0,0 +1 @@
+export class MetaValidator{#j;constructor(H){this.#j=H}validateShape(H,J){const v=H.name;for(const[w,F]of Object.entries(J)){if(F.type?.discriminator){const j=F.type.discriminator;if(typeof j.property!=="string"||j.property.length===0)throw new x(`${v}.${w}: discriminator.property must be a non-empty string.`);if(L.has(j.property))throw new x(`${v}.${w}: discriminator.property '${j.property}' is a reserved property name and cannot be used.`);if(!Array.isArray(j.subTypes)||j.subTypes.length===0)throw new x(`${v}.${w}: discriminator.subTypes must be a non-empty array of { value, name } entries.`);const G=new Set;for(let z=0;z<j.subTypes.length;z++){const q=j.subTypes[z];if(typeof q.name!=="string"||q.name.length===0)throw new x(`${v}.${w}: discriminator.subTypes[${z}].name must be a non-empty string.`);if(typeof q.value!=="function")throw new x(`${v}.${w}: discriminator.subTypes[${z}].value must be a class constructor (got ${typeof q.value}).`);if(G.has(q.name))throw new x(`${v}.${w}: discriminator.subTypes has duplicate name '${q.name}'. Each subType must have a unique name.`);G.add(q.name);if(!this.#j.hasOwn(q.value))throw new x(`${v}.${w}: discriminator.subTypes[${z}].value (${q.value.name}) has no @Field decorators.`)}}const I=F.type?.collection;if(I!==void 0&&F.type?.resolvedCollectionValue){const j=F.type.resolvedCollectionValue;if(!this.#j.hasOwn(j)){const G=I===K.Set?"setValue":"mapValue";throw new x(`${v}.${w}: ${G} target (${j.name}) has no @Field decorators.`)}}}}}import{BakerError as x}from"../common/index.js";import{CollectionType as K}from"../metadata/index.js";import{RESERVED_PROPERTY_NAMES as L}from"./constants.js";

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

@@ -1,31 +1,7 @@
-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>;
-/** Canonical fingerprint of a SealOptions — the 5 booleans in fixed order. `{}` and a fully-defaulted
- * object both map to "00000", so `new Baker()` and `new Baker({})` share a cache key. */
-declare function configFingerprint(o: SealOptions): string;
-declare function getCached(cls: Function, fp: string): SealedExecutors<unknown> | undefined;
-/** Test-only: drop a single class's cached executors so a re-seal recompiles it. */
-declare function clearCached(cls: Function): void;
+import type { SealOptions, SealedExecutors } from './interfaces';
 /**
- * Test-only: drop the ENTIRE cache. Used by `unseal()` so a test that re-seals classes starts from a
- * clean slate — a whole-cache reset (vs per-class) is the only way to avoid the partial-clear state
- * where a cached root still references a nested whose entry was dropped (a root + its nested are always
- * compiled together, so they must be invalidated together).
+ * Seal every class in `registry` with `options`, writing executors into `executors`. The core used by
+ * `new Baker().seal()` — a thin entry point over one {@link SealRun}.
  */
-declare function clearAllCached(): void;
 declare function sealRegistry(registry: Set<Function>, options: SealOptions, executors: Map<Function, SealedExecutors<unknown>>): void;
-/**
- * Merges RAW metadata child-first along the prototype chain of Class.
- *
- * Merge rules:
- * - validation: union merge (both parent and child apply, duplicate rules removed)
- * - transform: child takes priority, inherits from parent if absent in child
- * - expose: child takes priority, inherits from parent if absent in child
- * - exclude: child takes priority, inherits from parent if absent in child
- * - type: child takes priority, inherits from parent if absent in child
- * - flags: child takes priority, only missing flags are supplemented from parent
- */
-declare function mergeInheritance(Class: Function): RawClassMeta;
-export { sealRegistry, mergeInheritance, circularPlaceholder, getCached, configFingerprint, clearCached, clearAllCached };
+export { sealRegistry };

package/dist/src/seal/seal.js

@@ -1 +1 @@
-import{CollectionType as R,Direction as P}from"../enums.js";import{BakerError as F}from"../errors.js";import{getRaw as h,hasRawOwn as x}from"../meta-access.js";import{isAsyncFunction as v}from"../utils.js";import{analyzeCircular as g}from"./circular-analyzer.js";import{buildDeserializeCode as f,buildValidateCode as y}from"./deserialize-builder.js";import{validateExposeStacks as u}from"./expose-validator.js";import{buildSerializeCode as C}from"./serialize-builder.js";import{validateMeta as p}from"./validate-meta.js";const n=new Set(["__proto__","constructor","prototype"]);const D=new Set([Number,String,Boolean,Date]);function circularPlaceholder(j){const G=`Circular dependency during seal: ${j} is still being sealed`;return{deserialize(){throw new F(G)},serialize(){throw new F(G)},validate(){throw new F(G)},isAsync:!1,isSerializeAsync:!1}}function O(j,G,H,J){const K=G===P.Deserialize?"isAsync":"isSerializeAsync",W=J??new Set,L=(Q)=>{if(W.has(Q))return!1;W.add(Q);const q=H(Q);if(q?.merged)return q[K]===!0;return O(mergeInheritance(Q),G,H,W)};for(const Q of Object.values(j)){if(G===P.Deserialize&&Q.validation.some((q)=>q.rule.isAsync))return!0;for(const q of Q.transform){if(G===P.Deserialize?q.options?.serializeOnly:q.options?.deserializeOnly)continue;if(q.isAsync??v(q.fn))return!0}if(k(Q).some(L))return!0}return!1}function k(j){const G=j.type;if(!G)return[];const H=[];if(G.resolvedClass)H.push(G.resolvedClass);if(G.resolvedCollectionValue)H.push(G.resolvedCollectionValue);if(G.discriminator)for(const J of G.discriminator.subTypes)H.push(J.value);if(H.length===0&&G.fn){const J=G.fn();if(J===Map||J===Set){const K=G.collectionValue?.();if(typeof K==="function"&&!D.has(K))H.push(K)}else{const K=Array.isArray(J)?J[0]:J;if(typeof K==="function"&&!D.has(K))H.push(K)}}return H}let _=new WeakMap;function configFingerprint(j){return(j.enableImplicitConversion?"1":"0")+(j.exposeDefaultValues?"1":"0")+(j.stopAtFirstError?"1":"0")+(j.whitelist?"1":"0")+(j.debug?"1":"0")}function getCached(j,G){return _.get(j)?.get(G)}function clearCached(j){_.delete(j)}function clearAllCached(){_=new WeakMap}function d(j,G,H){let J=_.get(j);if(J===void 0){J=new Map;_.set(j,J)}J.set(G,H)}function sealRegistry(j,G,H){const J=configFingerprint(G),K=new Set;try{for(const W of j)M(W,H,J,G,K)}catch(W){H.clear();throw W}for(const W of K)d(W,J,H.get(W));j.clear()}function M(j,G,H,J,K){if(G.has(j))return;const W=getCached(j,H);if(W!==void 0){G.set(j,W);if(W.merged)for(const q of Object.values(W.merged))for(const Y of k(q))M(Y,G,H,J,K);return}const L=circularPlaceholder(j.name);G.set(j,L);const Q=(q)=>G.get(q);try{const q=mergeInheritance(j);for(const $ of Object.keys(q))if(n.has($))throw new F(`${j.name}: field name '${$}' is not allowed (reserved property name)`);for(const[$,U]of Object.entries(q)){if(!U.type?.fn)continue;let w;try{w=U.type.fn()}catch(B){throw new F(`${j.name}.${$}: type function threw: ${B.message}`,{cause:B})}if(w===Map||w===Set){const B=w===Map?R.Map:R.Set,I={...U.type,collection:B,isArray:!1};if(U.type.collectionValue){let V;try{V=U.type.collectionValue()}catch(E){throw new F(`${j.name}.${$}: collectionValue function threw: ${E.message}`,{cause:E})}if(V!=null&&typeof V==="function"&&!D.has(V))I.resolvedCollectionValue=V}q[$]={...U,type:I};continue}const T=Array.isArray(w),N=T?w[0]:w;if(N==null||typeof N!=="function")throw new F(`${j.name}: @Type/@Field type must return a constructor or [constructor], got ${String(N)}`);const z={...U.type,isArray:T};if(!D.has(N)){z.resolvedClass=N;if(!U.flags.validateNested||!U.flags.validateNestedEach){U.flags={...U.flags};if(!U.flags.validateNested)U.flags.validateNested=!0;if(T&&!U.flags.validateNestedEach)U.flags.validateNestedEach=!0}}q[$]={...U,type:z}}u(q,j.name);p(j,q);const Y=g(j);for(const $ of Object.values(q)){if($.type?.resolvedClass)M($.type.resolvedClass,G,H,J,K);if($.type?.resolvedCollectionValue)M($.type.resolvedCollectionValue,G,H,J,K);if($.type?.discriminator)for(const U of $.type.discriminator.subTypes)M(U.value,G,H,J,K)}const X=O(q,P.Deserialize,Q),Z=O(q,P.Serialize,Q),b=f(j,q,J,Y,X,Q),S=y(j,q,J,Y,X,Q),A=C(j,q,J,Z,Q);Object.assign(L,{deserialize:b,serialize:A,validate:S,isAsync:X,isSerializeAsync:Z,merged:q})}catch(q){G.delete(j);throw q}K?.add(j)}function mergeInheritance(j){const G=[];let H=j;while(H&&H!==Object){if(x(H))G.push(H);const K=Object.getPrototypeOf(H);H=K===H?null:K}const J=Object.create(null);for(const K of G){const W=h(K);for(const[L,Q]of Object.entries(W))if(!J[L])J[L]={...Q,validation:[...Q.validation],transform:[...Q.transform],expose:[...Q.expose],exclude:Q.exclude,type:Q.type,flags:{...Q.flags}};else{const q=J[L],Y=Q;for(const b of Y.validation)if(!q.validation.some((S)=>S.rule.ruleName===b.rule.ruleName))q.validation.push(b);if(q.transform.length===0&&Y.transform.length>0)q.transform=[...Y.transform];if(q.expose.length===0&&Y.expose.length>0)q.expose=[...Y.expose];if(q.exclude===null&&Y.exclude!==null)q.exclude=Y.exclude;if(q.type===null&&Y.type!==null)q.type=Y.type;const X=q.flags,Z=Y.flags;if(Z.isOptional!==void 0&&X.isOptional===void 0)X.isOptional=Z.isOptional;if(Z.isDefined!==void 0&&X.isDefined===void 0)X.isDefined=Z.isDefined;if(Z.validateIf!==void 0&&X.validateIf===void 0)X.validateIf=Z.validateIf;if(Z.isNullable!==void 0&&X.isNullable===void 0)X.isNullable=Z.isNullable;if(Z.validateNested!==void 0&&X.validateNested===void 0)X.validateNested=Z.validateNested;if(Z.validateNestedEach!==void 0&&X.validateNestedEach===void 0)X.validateNestedEach=Z.validateNestedEach}}return J}export{sealRegistry,mergeInheritance,circularPlaceholder,getCached,configFingerprint,clearCached,clearAllCached};
+class W{executors;options;fp;sealed=new Map;inserted=new Set;resolve=(j)=>this.executors.get(j);#q;#F;#j;#G;constructor(j,F,G=N){this.executors=j;this.options=F;this.fp=L.fingerprint(F);this.#q=new T(G);this.#F=new Y(this.#q);this.#j=new O(this.resolve,this.#q);this.#G=new V(G)}run(j){try{for(const F of j)this.sealOne(F)}catch(F){for(const G of this.inserted)this.executors.delete(G);throw F}for(const[F,G]of this.sealed)L.set(F,this.fp,G);j.clear()}sealOne(j){if(this.executors.has(j))return;const F=L.get(j,this.fp);if(F!==void 0){this.executors.set(j,F);this.inserted.add(j);if(F.merged)for(const q of Object.values(F.merged))for(const H of this.#j.nestedClassesOf(q))this.sealOne(H);return}const G=new B(j.name);this.executors.set(j,G);this.inserted.add(j);try{const q=this.#q.merge(j);for(const J of Object.keys(q))if(_.has(J))throw new I(`${j.name}: field name '${J}' is not allowed (reserved property name)`);b(q,j.name);P(q,j.name);this.#G.validateShape(j,q);const H=this.#F.analyze(j);for(const J of Object.values(q))for(const f of this.#j.nestedClassesOf(J))this.sealOne(f);const K=this.#j.analyze(q,U.Deserialize),Q=this.#j.analyze(q,U.Serialize),X=w(j,q,this.options,H,K,this.resolve),Z=M(j,q,this.options,H,K,this.resolve),$=D(j,q,this.options,Q,this.resolve);Object.assign(G,{deserialize:X,serialize:$,validate:Z,isAsync:K,isSerializeAsync:Q,merged:q})}catch(q){this.executors.delete(j);throw q}this.sealed.set(j,G)}}import{Direction as U,BakerError as I}from"../common/index.js";import{metaStore as N}from"../metadata/index.js";import{AsyncAnalyzer as O}from"./async-analyzer.js";import{CircularAnalyzer as Y}from"./circular-analyzer.js";import{CircularPlaceholder as B}from"./circular-placeholder.js";import{compileCache as L}from"./compile-cache.js";import{RESERVED_PROPERTY_NAMES as _}from"./constants.js";import{buildDeserializeCode as w,buildValidateCode as M}from"./deserialize-builder.js";import{validateExposeStacks as P}from"./expose-validator.js";import{InheritanceMerger as T}from"./inheritance-merger.js";import{MetaValidator as V}from"./meta-validator.js";import{buildSerializeCode as D}from"./serialize-builder.js";import{normalizeTypeDefs as b}from"./type-normalizer.js";function sealRegistry(j,F,G){new W(G,F).run(j)}export{sealRegistry};

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

@@ -1,8 +1,10 @@
-import type { SealOptions, RuntimeOptions } from '../interfaces';
-import type { RawClassMeta, SealedExecutors } from '../types';
+import type { RuntimeOptions } from '../common';
+import type { RawClassMeta } from '../metadata';
+import type { SealOptions, SealedExecutors } from './interfaces';
 /**
  * Generate serialize executor code.
- * Assumes no validation — always returns Record<string, unknown> (§4.3).
+ * Thin wrapper preserving the historical free-function entry point: instantiates
+ * SerializeBuilder and returns its built executor.
  */
 declare function buildSerializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, isAsync: boolean, resolve: (cls: Function) => SealedExecutors<unknown> | undefined): (instance: T, opts?: RuntimeOptions) => Record<string, unknown> | Promise<Record<string, unknown>>;
 export { buildSerializeCode };

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

@@ -1,70 +1,70 @@
-import{CollectionType as c}from"../enums.js";import{BakerError as p}from"../errors.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 M=q.find((R)=>R.serializeOnly&&R.name);if(M)return M.name;const Q=q.find((R)=>!R.deserializeOnly&&!R.serializeOnly&&R.name);if(Q)return Q.name;return U}function y(U){let q=null;for(const M of U){if(M.deserializeOnly)continue;if(!M.groups||M.groups.length===0)return;if(q===null)q=new Set;for(const Q of M.groups)q.add(Q)}return q===null?void 0:[...q]}function x(U,q,M,Q){if(M.length===0)return null;if(M.length===1){const X=M[0],Z=Q.length;Q.push(X.fn);const W=`refs[${Z}]({value:${U},key:${JSON.stringify(q)},obj:instance})`;return X.isAsync?`(await ${W})`:W}if(M.length===2){const X=M[1],Z=M[0],W=Q.length;Q.push(X.fn);const B=Q.length;Q.push(Z.fn);const D=`refs[${W}]({value:${U},key:${JSON.stringify(q)},obj:instance})`,I=X.isAsync?`(await ${D})`:D,L=`refs[${B}]({value:${I},key:${JSON.stringify(q)},obj:instance})`;return Z.isAsync?`(await ${L})`:L}let R=U;for(let X=M.length-1;X>=0;X-=1){const Z=M[X],W=Q.length;Q.push(Z.fn);const B=`refs[${W}]({value:${R},key:${JSON.stringify(q)},obj:instance})`;R=Z.isAsync?`(await ${B})`:B}return R}function T(U,q,M,Q){const R=x(U,q,M,Q);return R?`
-${U} = ${R};`:""}function buildSerializeCode(U,q,M,Q,R){const X=[],Z=[];let W=`'use strict';
-`;W+=`var ${j.out} = {};
-`;if(Object.values(q).some((P)=>{const O=y(P.expose);return O&&O.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[P,O]of Object.entries(q))W+=f(P,O,X,Z,Q,R,M,U.name);W+=`return ${j.out};
-`;const D=U.name.replace(/[^\w$.-]/g,"_");W+=`//# sourceURL=baker://${D}/serialize
-`;return Function("refs","execs","BakerError",`return ${Q?"async function":"function"}(instance, opts) { `+W+" }")(X,Z,p)}function f(U,q,M,Q,R,X,Z,W=""){if(q.exclude){if(!q.exclude.deserializeOnly){if(Z?.debug){const Y=q.exclude.serializeOnly?"serializeOnly":"bidirectional";return`// [baker] field ${JSON.stringify(U)} excluded (${Y} @Exclude)
-`}return""}}if(q.expose.length>0&&q.expose.every((Y)=>Y.deserializeOnly)){if(Z?.debug)return`// [baker] field ${JSON.stringify(U)} excluded (all @Expose entries are deserializeOnly)
-`;return""}const B=u(U,q.expose),D=y(q.expose),I=E(U),L=`${j.fieldVal}${I}`;let P="";P+=`var ${L} = instance[${JSON.stringify(U)}];
-`;let O="",S="";if(D&&D.length>0){O=`if ((${j.group0} !== null || ${j.groupsSet}) && (${m(j.group0,j.groupsSet,D)})) {
-`;S=`}
-`}let $="";const b=q.flags.isOptional,V=q.transform.filter((Y)=>!Y.options?.deserializeOnly);if(q.type?.collection){const Y=`${j.out}[${JSON.stringify(B)}]`,_=q.type.collection;let J;if(_===c.Set)if(q.type.resolvedCollectionValue){const F=X(q.type.resolvedCollectionValue),h=Q.length;Q.push(F);if(R)J=`{ var __ser_ps = []; for (var __ser_item of ${L}) { __ser_ps.push(__ser_item == null ? __ser_item : execs[${h}].serialize(__ser_item, opts)); } ${Y} = await Promise.all(__ser_ps); }`;else{J=`var ${j.setArr} = [];
-`;J+=`  for (var ${j.setItem} of ${L}) {
-`;J+=`    ${j.setArr}.push(${j.setItem} == null ? ${j.setItem} : execs[${h}].serialize(${j.setItem}, opts));
-`;J+=`  }
-`;J+=`  ${Y} = ${j.setArr};`}}else J=`${Y} = [...${L}];`;else{const F=`if (typeof ${j.mapEntry}[0] !== 'string') { throw new BakerError(${JSON.stringify(W)} + ': Map field ' + ${JSON.stringify(U)} + ' has non-string key (' + typeof ${j.mapEntry}[0] + '). Map serialization requires string keys.'); }
-    `;if(q.type.resolvedCollectionValue){const h=X(q.type.resolvedCollectionValue),z=Q.length;Q.push(h);const v=R?"await ":"";J=`var ${j.mapObj} = Object.create(null);
-`;J+=`  for (var ${j.mapEntry} of ${L}) {
-`;J+=`    ${F}`;J+=`${j.mapObj}[${j.mapEntry}[0]] = ${j.mapEntry}[1] == null ? ${j.mapEntry}[1] : ${v}execs[${z}].serialize(${j.mapEntry}[1], opts);
-`;J+=`  }
-`;J+=`  ${Y} = ${j.mapObj};`}else{J=`var ${j.mapObj} = Object.create(null);
-`;J+=`  for (var ${j.mapEntry} of ${L}) {
-`;J+=`    ${F}`;J+=`${j.mapObj}[${j.mapEntry}[0]] = ${j.mapEntry}[1];
-`;J+=`  }
-`;J+=`  ${Y} = ${j.mapObj};`}}J+=T(Y,U,V,M);if(b)$=`if (${L} !== undefined && ${L} !== null) {
-  ${J}
-} else if (${L} === null) {
-  ${Y} = null;
+class x{refs=[];execs=[];Class;merged;options;isAsync;resolve;constructor(Q,M,U,Y,Z){this.Class=Q;this.merged=M;this.options=U;this.isAsync=Y;this.resolve=Z}build(){let Q=`'use strict';
+`;Q+=`var ${q.out} = {};
+`;let M=!1;for(const _ in this.merged){const j=this.merged[_];if(j===void 0)continue;const R=V(j.expose,b.Serialize);if(R&&R.length>0){M=!0;break}}if(M){Q+=`var ${q.groups} = opts && opts.groups;
+`;Q+=`var ${q.group0} = ${q.groups} && ${q.groups}.length === 1 ? ${q.groups}[0] : null;
+`;Q+=`var ${q.groupsSet} = ${q.groups} && ${q.groups}.length > 1 ? new Set(${q.groups}) : null;
+`}for(const[_,j]of Object.entries(this.merged))Q+=this.generateFieldCode(_,j);Q+=`return ${q.out};
+`;const U=this.Class.name.replace(/[^\w$.-]/g,"_");Q+=`//# sourceURL=baker://${U}/serialize
+`;const Y=this.isAsync?"async function":"function";return Function("refs","execs","BakerError",`return ${Y}(instance, opts) { `+Q+" }")(this.refs,this.execs,K)}resolveExecutor(Q){const M=this.resolve(Q);if(M===void 0)throw new K(`${this.Class.name}: nested class '${Q.name}' was not sealed before serialize codegen.`);return M}generateFieldCode(Q,M){const U=this.Class.name,Y=this.options;if(M.exclude){if(!M.exclude.deserializeOnly){if(Y?.debug){const W=M.exclude.serializeOnly?"serializeOnly":"bidirectional";return`// [baker] field ${JSON.stringify(Q)} excluded (${W} @Exclude)
+`}return""}}if(M.expose.length>0&&M.expose.every((W)=>W.deserializeOnly)){if(Y?.debug)return`// [baker] field ${JSON.stringify(Q)} excluded (all @Expose entries are deserializeOnly)
+`;return""}const Z=p(Q,M.expose,b.Serialize),_=V(M.expose,b.Serialize),j=E(Q),R=`${q.fieldVal}${j}`;let A="";A+=`var ${R} = instance[${JSON.stringify(Q)}];
+`;let v="",w="";if(_&&_.length>0){v=`if ((${q.group0} !== null || ${q.groupsSet}) && (${f(q.group0,q.groupsSet,_)})) {
+`;w=`}
+`}let J="";const I=M.flags.isOptional,g=M.transform.filter((W)=>!W.options?.deserializeOnly);if(M.type?.collection){const W=`${q.out}[${JSON.stringify(Z)}]`,$=M.type.collection;let L;if($===m.Set)if(M.type.resolvedCollectionValue){const H=this.resolveExecutor(M.type.resolvedCollectionValue),O=this.execs.length;this.execs.push(H);if(this.isAsync)L=`{ var __ser_ps${j} = []; for (var __ser_item${j} of ${R}) { __ser_ps${j}.push(__ser_item${j} == null ? __ser_item${j} : execs[${O}].serialize(__ser_item${j}, opts)); } ${W} = await Promise.all(__ser_ps${j}); }`;else{L=`var ${q.setArr}${j} = [];
+`;L+=`  for (var ${q.setItem}${j} of ${R}) {
+`;L+=`    ${q.setArr}${j}.push(${q.setItem}${j} == null ? ${q.setItem}${j} : execs[${O}].serialize(${q.setItem}${j}, opts));
+`;L+=`  }
+`;L+=`  ${W} = ${q.setArr}${j};`}}else L=`${W} = [...${R}];`;else{const H=`if (typeof ${q.mapEntry}${j}[0] !== 'string') { throw new BakerError(${JSON.stringify(U)} + ': Map field ' + ${JSON.stringify(Q)} + ' has non-string key (' + typeof ${q.mapEntry}${j}[0] + '). Map serialization requires string keys.'); }
+    `;if(M.type.resolvedCollectionValue){const O=this.resolveExecutor(M.type.resolvedCollectionValue),B=this.execs.length;this.execs.push(O);const D=this.isAsync?"await ":"";L=`var ${q.mapObj}${j} = Object.create(null);
+`;L+=`  for (var ${q.mapEntry}${j} of ${R}) {
+`;L+=`    ${H}`;L+=`${q.mapObj}${j}[${q.mapEntry}${j}[0]] = ${q.mapEntry}${j}[1] == null ? ${q.mapEntry}${j}[1] : ${D}execs[${B}].serialize(${q.mapEntry}${j}[1], opts);
+`;L+=`  }
+`;L+=`  ${W} = ${q.mapObj}${j};`}else{L=`var ${q.mapObj}${j} = Object.create(null);
+`;L+=`  for (var ${q.mapEntry}${j} of ${R}) {
+`;L+=`    ${H}`;L+=`${q.mapObj}${j}[${q.mapEntry}${j}[0]] = ${q.mapEntry}${j}[1];
+`;L+=`  }
+`;L+=`  ${W} = ${q.mapObj}${j};`}}L+=this.buildPostNestedTransformCode(W,Q,g);if(I)J=`if (${R} !== undefined && ${R} !== null) {
+  ${L}
+} else if (${R} === null) {
+  ${W} = null;
 }
-`;else $=`if (${L} != null) {
-  ${J}
+`;else J=`if (${R} != null) {
+  ${L}
 } else {
-  ${Y} = ${L};
+  ${W} = ${R};
 }
-`;P+=O+$+S;return P}if(q.type?.resolvedClass||q.type?.discriminator||q.type?.fn&&q.flags.validateNested){const Y=q.type?.isArray||q.flags.validateNestedEach||q.validation.some((F)=>F.each),_=`${j.out}[${JSON.stringify(B)}]`;let J;if(q.type.discriminator){const{property:F,subTypes:h}=q.type.discriminator,z=q.type.keepDiscriminatorProperty!==!1,v=[...h].sort((H,k)=>{if(H.value.prototype instanceof k.value)return-1;if(k.value.prototype instanceof H.value)return 1;return 0}),K=(H,k)=>{let w="";for(let A=0;A<v.length;A++){const g=v[A],N=X(g.value),C=Q.length;Q.push(N);const G=M.length;M.push(g.value);w+=`${A===0?"if":"} else if"} (${H} instanceof refs[${G}]) {
-`;w+=`  var ${j.serResult} = ${k}execs[${C}].serialize(${H}, opts);
-`;if(z)w+=`  ${j.serResult}[${JSON.stringify(F)}] = ${JSON.stringify(g.name)};
-`;w+=`  ${j.outItem} = ${j.serResult};
-`}w+=`} else { ${j.outItem} = `+H+`; }
-`;return w};if(Y){const H=R?"await ":"";if(R)J=`${_} = await Promise.all(${L}.map(async function(__ser_item) {
-`;else{J=`var ${j.discArr} = [];
-`;J+=`  for (var ${j.discIdx}=0; ${j.discIdx}<${L}.length; ${j.discIdx}++) {
-`;J+=`    var __ser_item = ${L}[${j.discIdx}];
-`}J+=`    var ${j.outItem};
-`;J+=K("__ser_item",H);if(R){J+=`  return ${j.outItem};
-`;J+="}));"}else{J+=`    ${j.discArr}.push(${j.outItem});
-`;J+=`  }
-`;J+=`  ${_} = ${j.discArr};`}}else{const H=R?"await ":"";J=`var ${j.outItem};
-`;J+=K(L,H);J+=`${_} = ${j.outItem};`}}else{const F=q.type.resolvedClass??q.type.fn(),h=X(F),z=Q.length;Q.push(h);if(Y)if(R)J=`${_} = await Promise.all(${L}.map(async function(__ser_item) { return __ser_item == null ? __ser_item : await execs[${z}].serialize(__ser_item, opts); }));`;else{J=`var ${j.nestedArr} = [];
-`;J+=`  for (var ${j.nestedIdx}=0; ${j.nestedIdx}<${L}.length; ${j.nestedIdx}++) {
-`;J+=`    var ${j.nestedItem} = ${L}[${j.nestedIdx}];
-`;J+=`    ${j.nestedArr}.push(${j.nestedItem} == null ? ${j.nestedItem} : execs[${z}].serialize(${j.nestedItem}, opts));
-`;J+=`  }
-`;J+=`  ${_} = ${j.nestedArr};`}else J=`${_} = ${R?"await ":""}execs[${z}].serialize(${L}, opts);`}J+=T(_,U,V,M);if(b)$=`if (${L} !== undefined && ${L} !== null) {
-  ${J}
-} else if (${L} === null) {
-  ${_} = null;
+`;A+=v+J+w;return A}const F=M.type;if(F&&(F.resolvedClass||F.discriminator||F.fn!==void 0&&M.flags.validateNested)){const W=F.isArray||M.flags.validateNestedEach||M.validation.some((H)=>H.each),$=`${q.out}[${JSON.stringify(Z)}]`;let L;if(F.discriminator){const{property:H,subTypes:O}=F.discriminator,B=F.keepDiscriminatorProperty===!0,D=O.map((X,P)=>({sub:X,index:P,depth:u(X.value)})).sort((X,P)=>P.depth-X.depth||X.index-P.index).map((X)=>X.sub),T=(X,P)=>{let z="";for(let S=0;S<D.length;S++){const h=D[S],C=this.resolveExecutor(h.value),N=this.execs.length;this.execs.push(C);const G=this.refs.length;this.refs.push(h.value);z+=`${S===0?"if":"} else if"} (${X} instanceof refs[${G}]) {
+`;z+=`  var ${q.serResult}${j} = ${P}execs[${N}].serialize(${X}, opts);
+`;if(B)z+=`  ${q.serResult}${j}[${JSON.stringify(H)}] = ${JSON.stringify(h.name)};
+`;z+=`  ${q.outItem}${j} = ${q.serResult}${j};
+`}const c=JSON.stringify(JSON.stringify(O.map((S)=>S.name))),y=`(${X} == null ? ${X} : ${X}[${JSON.stringify(H)}])`,k=JSON.stringify(`${U}.${Q}: value matches no discriminator subtype (received discriminator=`);z+=`} else { throw new BakerError(${k} + JSON.stringify(${y}) + ${JSON.stringify(", expected one of ")} + ${c} + ${JSON.stringify(")")}); }
+`;return z};if(W){const X=this.isAsync?"await ":"",P=`__ser_item${j}`;if(this.isAsync)L=`${$} = await Promise.all(${R}.map(async function(${P}) {
+`;else{L=`var ${q.discArr}${j} = [];
+`;L+=`  for (var ${q.discIdx}${j}=0; ${q.discIdx}${j}<${R}.length; ${q.discIdx}${j}++) {
+`;L+=`    var ${P} = ${R}[${q.discIdx}${j}];
+`}L+=`    var ${q.outItem}${j};
+`;L+=T(P,X);if(this.isAsync){L+=`  return ${q.outItem}${j};
+`;L+="}));"}else{L+=`    ${q.discArr}${j}.push(${q.outItem}${j});
+`;L+=`  }
+`;L+=`  ${$} = ${q.discArr}${j};`}}else{const X=this.isAsync?"await ":"";L=`var ${q.outItem}${j};
+`;L+=T(R,X);L+=`${$} = ${q.outItem}${j};`}}else{const H=F.resolvedClass,O=this.resolveExecutor(H),B=this.execs.length;this.execs.push(O);if(W)if(this.isAsync)L=`${$} = await Promise.all(${R}.map(async function(__ser_item) { return __ser_item == null ? __ser_item : await execs[${B}].serialize(__ser_item, opts); }));`;else{L=`var ${q.nestedArr}${j} = [];
+`;L+=`  for (var ${q.nestedIdx}${j}=0; ${q.nestedIdx}${j}<${R}.length; ${q.nestedIdx}${j}++) {
+`;L+=`    var ${q.nestedItem}${j} = ${R}[${q.nestedIdx}${j}];
+`;L+=`    ${q.nestedArr}${j}.push(${q.nestedItem}${j} == null ? ${q.nestedItem}${j} : execs[${B}].serialize(${q.nestedItem}${j}, opts));
+`;L+=`  }
+`;L+=`  ${$} = ${q.nestedArr}${j};`}else{const D=this.isAsync?"await ":"";L=`${$} = ${D}execs[${B}].serialize(${R}, opts);`}}L+=this.buildPostNestedTransformCode($,Q,g);if(I)J=`if (${R} !== undefined && ${R} !== null) {
+  ${L}
+} else if (${R} === null) {
+  ${$} = null;
 }
-`;else $=`if (${L} != null) {
-  ${J}
+`;else J=`if (${R} != null) {
+  ${L}
 } else {
-  ${_} = ${L};
+  ${$} = ${R};
 }
-`}else{const Y=n(U,B,L,q,M);if(b){$+=`if (${L} !== undefined) {
-`;$+="  "+Y+`
-`;$+=`}
-`}else $+=Y+`
-`}P+=O+$+S;return P}function n(U,q,M,Q,R){const X=`${j.out}[${JSON.stringify(q)}]`,Z=Q.transform.filter((W)=>!W.options?.deserializeOnly);if(Z.length>0){const W=x(M,U,Z,R);return`${X} = ${W};`}return`${X} = ${M};`}export{buildSerializeCode};
+`}else{const W=this.buildOutputExpr(Q,Z,R,M);if(I){J+=`if (${R} !== undefined) {
+`;J+="  "+W+`
+`;J+=`}
+`}else J+=W+`
+`}A+=v+J+w;return A}buildTransformExpr(Q,M,U){if(U.length===0)return null;const Y=this.refs;let Z=Q;for(let _=U.length-1;_>=0;_-=1){const j=U[_],R=Y.length;Y.push(j.fn);const A=`refs[${R}]({value:${Z},key:${JSON.stringify(M)},obj:instance})`;Z=j.isAsync?`(await ${A})`:A}return Z}buildPostNestedTransformCode(Q,M,U){const Y=this.buildTransformExpr(Q,M,U);return Y?`
+${Q} = ${Y};`:""}buildOutputExpr(Q,M,U,Y){const Z=`${q.out}[${JSON.stringify(M)}]`,_=Y.transform.filter((j)=>!j.options?.deserializeOnly);if(_.length>0){const j=this.buildTransformExpr(U,Q,_);return`${Z} = ${j};`}return`${Z} = ${U};`}}import{BakerError as K,Direction as b}from"../common/index.js";import{CollectionType as m}from"../metadata/index.js";import{sanitizeKey as E,buildGroupsHasExpr as f,resolveExposeName as p,resolveExposeGroups as V}from"./codegen-utils.js";import{SER_GEN as q}from"./constants.js";function u(Q){let M=0,U=Object.getPrototypeOf(Q);while(typeof U==="function"){M+=1;U=Object.getPrototypeOf(U)}return M}function buildSerializeCode(Q,M,U,Y,Z){return new x(Q,M,U,Y,Z).build()}export{buildSerializeCode};

package/dist/src/seal/type-normalizer.d.ts

@@ -0,0 +1,9 @@
+import type { RawClassMeta } from '../metadata';
+/**
+ * Seal-time normalization of each field's `@Type`/`@Field` type thunk: resolve `type.fn()`, detect
+ * Map/Set collections and the `[Element]` array form, exclude primitive constructors, and auto-infer the
+ * `validateNested`/`validateNestedEach` flags for DTO classes. Mutates `merged` in place — it reassigns
+ * `merged[key]` with a copy-on-write `type` (never mutating the shared RAW `type`) and mutates the
+ * already-per-seal-cloned `meta.flags` directly. Stateless — a plain function (no instance needed).
+ */
+export declare function normalizeTypeDefs(merged: RawClassMeta, className: string): void;

package/dist/src/seal/type-normalizer.js

@@ -0,0 +1 @@
+import{BakerError as H}from"../common/index.js";import{PRIMITIVE_CTORS as U}from"./constants.js";import{classifyTypeResult as W}from"./type-resolver.js";export function normalizeTypeDefs(F,G){for(const[z,b]of Object.entries(F)){if(!b.type?.fn)continue;let J;try{J=b.type.fn()}catch(j){throw new H(`${G}.${z}: type function threw: ${j instanceof Error?j.message:String(j)}`,{cause:j})}const{collection:K,isArray:L,resolved:q}=W(J);if(K!==void 0){const j={...b.type,collection:K,isArray:!1};if(b.type.collectionValue){let x;try{x=b.type.collectionValue()}catch(D){throw new H(`${G}.${z}: collectionValue function threw: ${D instanceof Error?D.message:String(D)}`,{cause:D})}if(x!=null&&typeof x==="function"&&!U.has(x))j.resolvedCollectionValue=x}F[z]={...b,type:j};continue}if(q==null||typeof q!=="function")throw new H(`${G}: @Type/@Field type must return a constructor or [constructor], got ${String(q)}`);const Q={...b.type,isArray:L};if(!U.has(q)){Q.resolvedClass=q;if(!b.flags.validateNested)b.flags.validateNested=!0;if(L&&!b.flags.validateNestedEach)b.flags.validateNestedEach=!0}F[z]={...b,type:Q}}}

package/dist/src/seal/type-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { ClassifiedType } from './interfaces';
+export declare function classifyTypeResult(result: unknown): ClassifiedType;

package/dist/src/seal/type-resolver.js

@@ -0,0 +1 @@
+import{CollectionType as i}from"../metadata/index.js";export function classifyTypeResult(e){if(e===Map)return{collection:i.Map,isArray:!1,resolved:void 0};if(e===Set)return{collection:i.Set,isArray:!1,resolved:void 0};const r=Array.isArray(e);return{isArray:r,resolved:r?e[0]:e}}

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

@@ -0,0 +1,6 @@
+import type { Result, ResultAsync } from '@zipbul/result';
+import type { RuntimeOptions, BakerIssue } from '../common';
+/** Compiled deserialize executor — Result pattern (or its async variant), produced by the builder. */
+export type DeserializeExecutor<T> = (input: unknown, opts?: RuntimeOptions) => Result<T, BakerIssue[]> | ResultAsync<T, BakerIssue[]>;
+/** Compiled validate-only executor — null on success, BakerIssue[] on failure (or its async variant). */
+export type ValidateExecutor = (input: unknown, opts?: RuntimeOptions) => BakerIssue[] | null | Promise<BakerIssue[] | null>;