@zipbul/baker 3.3.1 → 3.4.1

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

@@ -1,374 +1,70 @@
-import { BakerError } from '../errors.js';
-import { getSealed } from '../meta-access.js';
-import { sanitizeKey, buildGroupsHasExpr } from './codegen-utils.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Generated variable name prefixes — centralised to prevent typo-related bugs
-// ─────────────────────────────────────────────────────────────────────────────
-const GEN = {
-    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',
-};
-// ─────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-/** Determine the output key for serialize direction */
-function getSerializeOutputKey(fieldKey, exposeStack) {
-    // serializeOnly @Expose with name → use that name
-    const serDef = exposeStack.find(e => e.serializeOnly && e.name);
-    if (serDef) {
-        return serDef.name;
-    }
-    // Non-directional @Expose with name → use for both directions
-    const biDef = exposeStack.find(e => !e.deserializeOnly && !e.serializeOnly && e.name);
-    if (biDef) {
-        return biDef.name;
-    }
-    return fieldKey;
+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?`
+${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};
+`;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""}}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)})) {
+`;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} = [];
+`;J+=`  for (var ${j.setItem} of ${Q}) {
+`;J+=`    ${j.setArr}.push(${j.setItem} == null ? ${j.setItem} : execs[${D}].serialize(${j.setItem}, opts));
+`;J+=`  }
+`;J+=`  ${X} = ${j.setArr};`}}else J=`${X} = [...${Q}];`;else{const B=`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 D=A(q.type.resolvedCollectionValue),O=M.length;M.push(D);const w=R?"await ":"";J=`var ${j.mapObj} = Object.create(null);
+`;J+=`  for (var ${j.mapEntry} of ${Q}) {
+`;J+=`    ${B}`;J+=`${j.mapObj}[${j.mapEntry}[0]] = ${j.mapEntry}[1] == null ? ${j.mapEntry}[1] : ${w}execs[${O}].serialize(${j.mapEntry}[1], opts);
+`;J+=`  }
+`;J+=`  ${X} = ${j.mapObj};`}else{J=`var ${j.mapObj} = Object.create(null);
+`;J+=`  for (var ${j.mapEntry} of ${Q}) {
+`;J+=`    ${B}`;J+=`${j.mapObj}[${j.mapEntry}[0]] = ${j.mapEntry}[1];
+`;J+=`  }
+`;J+=`  ${X} = ${j.mapObj};`}}J+=T(X,U,g,L);if(b)H=`if (${Q} !== undefined && ${Q} !== null) {
+  ${J}
+} else if (${Q} === null) {
+  ${X} = null;
 }
-/** Determine expose groups for serialize direction — returns undefined (no restriction) if any unconditional expose entry exists */
-function getSerializeExposeGroups(exposeStack) {
-    // Single-pass: scan once, build set of groups; bail out as soon as we see an unconditional entry.
-    let all = null;
-    for (const e of exposeStack) {
-        if (e.deserializeOnly) {
-            continue;
-        }
-        if (!e.groups || e.groups.length === 0) {
-            return undefined;
-        }
-        if (all === null) {
-            all = new Set();
-        }
-        for (const g of e.groups) {
-            all.add(g);
-        }
-    }
-    return all === null ? undefined : [...all];
+`;else H=`if (${Q} != null) {
+  ${J}
+} else {
+  ${X} = ${Q};
 }
-/**
- * Build serialize-direction transform expression.
- * Serialize direction reverses declaration order (codec stack unwrapping).
- */
-function buildSerializeTransformExpr(inputExpr, fieldKey, serTransforms, refs) {
-    if (serTransforms.length === 0) {
-        return null;
-    }
-    if (serTransforms.length === 1) {
-        const td = serTransforms[0];
-        const refIdx = refs.length;
-        refs.push(td.fn);
-        const callExpr = `refs[${refIdx}]({value:${inputExpr},key:${JSON.stringify(fieldKey)},obj:instance})`;
-        return td.isAsync ? `(await ${callExpr})` : callExpr;
-    }
-    if (serTransforms.length === 2) {
-        const td1 = serTransforms[1];
-        const td0 = serTransforms[0];
-        const refIdx1 = refs.length;
-        refs.push(td1.fn);
-        const refIdx0 = refs.length;
-        refs.push(td0.fn);
-        const call1 = `refs[${refIdx1}]({value:${inputExpr},key:${JSON.stringify(fieldKey)},obj:instance})`;
-        const expr1 = td1.isAsync ? `(await ${call1})` : call1;
-        const call0 = `refs[${refIdx0}]({value:${expr1},key:${JSON.stringify(fieldKey)},obj:instance})`;
-        return td0.isAsync ? `(await ${call0})` : call0;
-    }
-    // Walk serTransforms backwards in place — avoids [...arr].reverse() clone allocation
-    let valueExpr = inputExpr;
-    for (let k = serTransforms.length - 1; k >= 0; k -= 1) {
-        const td = serTransforms[k];
-        const refIdx = refs.length;
-        refs.push(td.fn);
-        const callExpr = `refs[${refIdx}]({value:${valueExpr},key:${JSON.stringify(fieldKey)},obj:instance})`;
-        valueExpr = td.isAsync ? `(await ${callExpr})` : callExpr;
-    }
-    return valueExpr;
+`;_+=v+H+S;return _}if(q.type?.resolvedClass||q.type?.discriminator||q.type?.fn&&q.flags.validateNested){const X=q.type?.isArray||q.flags.validateNestedEach||q.validation.some((B)=>B.each),$=`${j.out}[${JSON.stringify(Z)}]`;let J;if(q.type.discriminator){const{property:B,subTypes:D}=q.type.discriminator,O=q.type.keepDiscriminatorProperty!==!1,w=[...D].sort((P,I)=>{if(P.value.prototype instanceof I.value)return-1;if(I.value.prototype instanceof P.value)return 1;return 0}),K=(P,I)=>{let h="";for(let k=0;k<w.length;k++){const V=w[k],N=A(V.value),C=M.length;M.push(N);const G=L.length;L.push(V.value);h+=`${k===0?"if":"} else if"} (${P} instanceof refs[${G}]) {
+`;h+=`  var ${j.serResult} = ${I}execs[${C}].serialize(${P}, opts);
+`;if(O)h+=`  ${j.serResult}[${JSON.stringify(B)}] = ${JSON.stringify(V.name)};
+`;h+=`  ${j.outItem} = ${j.serResult};
+`}h+=`} else { ${j.outItem} = `+P+`; }
+`;return h};if(X){const P=R?"await ":"";if(R)J=`${$} = await Promise.all(${Q}.map(async function(__ser_item) {
+`;else{J=`var ${j.discArr} = [];
+`;J+=`  for (var ${j.discIdx}=0; ${j.discIdx}<${Q}.length; ${j.discIdx}++) {
+`;J+=`    var __ser_item = ${Q}[${j.discIdx}];
+`}J+=`    var ${j.outItem};
+`;J+=K("__ser_item",P);if(R){J+=`  return ${j.outItem};
+`;J+="}));"}else{J+=`    ${j.discArr}.push(${j.outItem});
+`;J+=`  }
+`;J+=`  ${$} = ${j.discArr};`}}else{const P=R?"await ":"";J=`var ${j.outItem};
+`;J+=K(Q,P);J+=`${$} = ${j.outItem};`}}else{const B=q.type.resolvedClass??q.type.fn(),D=A(B),O=M.length;M.push(D);if(X)if(R)J=`${$} = await Promise.all(${Q}.map(async function(__ser_item) { return __ser_item == null ? __ser_item : await execs[${O}].serialize(__ser_item, opts); }));`;else{J=`var ${j.nestedArr} = [];
+`;J+=`  for (var ${j.nestedIdx}=0; ${j.nestedIdx}<${Q}.length; ${j.nestedIdx}++) {
+`;J+=`    var ${j.nestedItem} = ${Q}[${j.nestedIdx}];
+`;J+=`    ${j.nestedArr}.push(${j.nestedItem} == null ? ${j.nestedItem} : execs[${O}].serialize(${j.nestedItem}, opts));
+`;J+=`  }
+`;J+=`  ${$} = ${j.nestedArr};`}else J=`${$} = ${R?"await ":""}execs[${O}].serialize(${Q}, opts);`}J+=T($,U,g,L);if(b)H=`if (${Q} !== undefined && ${Q} !== null) {
+  ${J}
+} else if (${Q} === null) {
+  ${$} = null;
 }
-/**
- * Generate transform chain code to apply after nested/collection serialize.
- * Reads the current value from outputTarget, chains transforms, writes back.
- */
-function buildPostNestedTransformCode(outputTarget, fieldKey, serTransforms, refs) {
-    const transformed = buildSerializeTransformExpr(outputTarget, fieldKey, serTransforms, refs);
-    return transformed ? `\n${outputTarget} = ${transformed};` : '';
+`;else H=`if (${Q} != null) {
+  ${J}
+} else {
+  ${$} = ${Q};
 }
-// ─────────────────────────────────────────────────────────────────────────────
-// buildSerializeCode — new Function-based serialize executor generation (§4.3 serialize pipeline)
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Generate serialize executor code.
- * Assumes no validation — always returns Record<string, unknown> (§4.3).
- */
-function buildSerializeCode(Class, merged, options, isAsync) {
-    const refs = [];
-    const execs = [];
-    // ── Code generation ────────────────────────────────────────────────────────
-    let body = "'use strict';\n";
-    body += `var ${GEN.out} = {};\n`;
-    // Groups variable — only when fields referencing groups exist
-    const hasGroupsField = Object.values(merged).some(meta => {
-        const groups = getSerializeExposeGroups(meta.expose);
-        return groups && groups.length > 0;
-    });
-    if (hasGroupsField) {
-        body += `var ${GEN.groups} = opts && opts.groups;\n`;
-        body += `var ${GEN.group0} = ${GEN.groups} && ${GEN.groups}.length === 1 ? ${GEN.groups}[0] : null;\n`;
-        body += `var ${GEN.groupsSet} = ${GEN.groups} && ${GEN.groups}.length > 1 ? new Set(${GEN.groups}) : null;\n`;
-    }
-    for (const [fieldKey, meta] of Object.entries(merged)) {
-        body += generateSerializeFieldCode(fieldKey, meta, refs, execs, isAsync, options, Class.name);
-    }
-    body += `return ${GEN.out};\n`;
-    // sourceURL (§4.9)
-    // Sanitize class name so it cannot inject newlines / */ that would break out of the comment.
-    const safeClsName = Class.name.replace(/[^\w$.-]/g, '_');
-    body += `//# sourceURL=baker://${safeClsName}/serialize\n`;
-    // ── Execute new Function ───────────────────────────────────────────────────
-    const fnKeyword = isAsync ? 'async function' : 'function';
-    const executor = new Function('refs', 'execs', 'BakerError', `return ${fnKeyword}(instance, opts) { ` + body + ' }')(refs, execs, BakerError);
-    return executor;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Per-field serialize code generation
-// ─────────────────────────────────────────────────────────────────────────────
-function generateSerializeFieldCode(fieldKey, meta, refs, execs, isAsync, options, className = '') {
-    // ⓪ Exclude serializeOnly / bidirectional → skip
-    if (meta.exclude) {
-        if (!meta.exclude.deserializeOnly) {
-            if (options?.debug) {
-                const reason = meta.exclude.serializeOnly ? 'serializeOnly' : 'bidirectional';
-                return `// [baker] field ${JSON.stringify(fieldKey)} excluded (${reason} @Exclude)\n`;
-            }
-            return '';
-        }
-    }
-    // Expose: if all @Expose entries are deserializeOnly, skip for serialize
-    if (meta.expose.length > 0 && meta.expose.every(e => e.deserializeOnly)) {
-        if (options?.debug) {
-            return `// [baker] field ${JSON.stringify(fieldKey)} excluded (all @Expose entries are deserializeOnly)\n`;
-        }
-        return '';
-    }
-    const outputKey = getSerializeOutputKey(fieldKey, meta.expose);
-    const exposeGroups = getSerializeExposeGroups(meta.expose);
-    const sk = sanitizeKey(fieldKey);
-    const fieldVal = `${GEN.fieldVal}${sk}`;
-    let fieldCode = '';
-    fieldCode += `var ${fieldVal} = instance[${JSON.stringify(fieldKey)}];\n`;
-    // groups check wrap (§4.5)
-    let fieldStart = '';
-    let fieldEnd = '';
-    if (exposeGroups && exposeGroups.length > 0) {
-        fieldStart = `if ((${GEN.group0} !== null || ${GEN.groupsSet}) && (${buildGroupsHasExpr(GEN.group0, GEN.groupsSet, exposeGroups)})) {\n`;
-        fieldEnd = '}\n';
-    }
-    let innerCode = '';
-    // ② @IsOptional → skip output if undefined (§4.3 serialize step 2)
-    const useOptionalGuard = meta.flags.isOptional;
-    // Collect serialize-direction transforms once
-    const serTransforms = meta.transform.filter(td => !td.options?.deserializeOnly);
-    // ③a Collection (Map/Set) serialize — Set → Array, Map → plain object
-    if (meta.type?.collection) {
-        const outputTarget = `${GEN.out}[${JSON.stringify(outputKey)}]`;
-        const collection = meta.type.collection;
-        let nestedCode;
-        if (collection === 'Set') {
-            if (meta.type.resolvedCollectionValue) {
-                const nestedSealed = getSealed(meta.type.resolvedCollectionValue);
-                const execIdx = execs.length;
-                execs.push(nestedSealed);
-                if (isAsync) {
-                    nestedCode = `{ var __ser_ps = []; for (var __ser_item of ${fieldVal}) { __ser_ps.push(__ser_item == null ? __ser_item : execs[${execIdx}].serialize(__ser_item, opts)); } ${outputTarget} = await Promise.all(__ser_ps); }`;
-                }
-                else {
-                    nestedCode = `var ${GEN.setArr} = [];\n`;
-                    nestedCode += `  for (var ${GEN.setItem} of ${fieldVal}) {\n`;
-                    nestedCode += `    ${GEN.setArr}.push(${GEN.setItem} == null ? ${GEN.setItem} : execs[${execIdx}].serialize(${GEN.setItem}, opts));\n`;
-                    nestedCode += `  }\n`;
-                    nestedCode += `  ${outputTarget} = ${GEN.setArr};`;
-                }
-            }
-            else {
-                nestedCode = `${outputTarget} = [...${fieldVal}];`;
-            }
-        }
-        else {
-            // Map → plain object (W8: keys must be strings — throw otherwise)
-            const keyCheck = `if (typeof ${GEN.mapEntry}[0] !== 'string') { throw new BakerError(${JSON.stringify(className)} + ': Map field ' + ${JSON.stringify(fieldKey)} + ' has non-string key (' + typeof ${GEN.mapEntry}[0] + '). Map serialization requires string keys.'); }\n    `;
-            if (meta.type.resolvedCollectionValue) {
-                const nestedSealed = getSealed(meta.type.resolvedCollectionValue);
-                const execIdx = execs.length;
-                execs.push(nestedSealed);
-                const awaitKw = isAsync ? 'await ' : '';
-                nestedCode = `var ${GEN.mapObj} = Object.create(null);\n`;
-                nestedCode += `  for (var ${GEN.mapEntry} of ${fieldVal}) {\n`;
-                nestedCode += `    ${keyCheck}`;
-                nestedCode += `${GEN.mapObj}[${GEN.mapEntry}[0]] = ${GEN.mapEntry}[1] == null ? ${GEN.mapEntry}[1] : ${awaitKw}execs[${execIdx}].serialize(${GEN.mapEntry}[1], opts);\n`;
-                nestedCode += `  }\n`;
-                nestedCode += `  ${outputTarget} = ${GEN.mapObj};`;
-            }
-            else {
-                nestedCode = `var ${GEN.mapObj} = Object.create(null);\n`;
-                nestedCode += `  for (var ${GEN.mapEntry} of ${fieldVal}) {\n`;
-                nestedCode += `    ${keyCheck}`;
-                nestedCode += `${GEN.mapObj}[${GEN.mapEntry}[0]] = ${GEN.mapEntry}[1];\n`;
-                nestedCode += `  }\n`;
-                nestedCode += `  ${outputTarget} = ${GEN.mapObj};`;
-            }
-        }
-        // Apply serialize transforms after collection serialize (nested → transform)
-        nestedCode += buildPostNestedTransformCode(outputTarget, fieldKey, serTransforms, refs);
-        if (useOptionalGuard) {
-            innerCode = `if (${fieldVal} !== undefined && ${fieldVal} !== null) {\n  ${nestedCode}\n} else if (${fieldVal} === null) {\n  ${outputTarget} = null;\n}\n`;
-        }
-        else {
-            innerCode = `if (${fieldVal} != null) {\n  ${nestedCode}\n} else {\n  ${outputTarget} = ${fieldVal};\n}\n`;
-        }
-        fieldCode += fieldStart + innerCode + fieldEnd;
-        return fieldCode;
-    }
-    // ③b nested @Type handling (H4) — supports type + transform combination (nested serialize → transform)
-    if (meta.type?.resolvedClass || meta.type?.discriminator || (meta.type?.fn && meta.flags.validateNested)) {
-        // Determine array/each mode
-        const hasEach = meta.type?.isArray || meta.flags.validateNestedEach || meta.validation.some(rd => rd.each);
-        const outputTarget = `${GEN.out}[${JSON.stringify(outputKey)}]`;
-        let nestedCode;
-        if (meta.type.discriminator) {
-            // §C-8 discriminator serialize — instanceof dispatch
-            const { property, subTypes } = meta.type.discriminator;
-            const keepDisc = meta.type.keepDiscriminatorProperty !== false; // default true for round-trip
-            // Sort most-specific-first (subclasses take priority in inheritance relationships)
-            const sorted = [...subTypes].sort((a, b) => {
-                if (a.value.prototype instanceof b.value) {
-                    return -1;
-                }
-                if (b.value.prototype instanceof a.value) {
-                    return 1;
-                }
-                return 0;
-            });
-            // Helper for generating instanceof branch code
-            const buildInstanceofChain = (itemVar, awaitKw) => {
-                let code = '';
-                for (let i = 0; i < sorted.length; i++) {
-                    const sub = sorted[i];
-                    const nestedSealed = getSealed(sub.value);
-                    const execIdx = execs.length;
-                    execs.push(nestedSealed);
-                    const refIdx = refs.length;
-                    refs.push(sub.value);
-                    const prefix = i === 0 ? 'if' : '} else if';
-                    code += `${prefix} (${itemVar} instanceof refs[${refIdx}]) {\n`;
-                    code += `  var ${GEN.serResult} = ${awaitKw}execs[${execIdx}].serialize(${itemVar}, opts);\n`;
-                    if (keepDisc) {
-                        code += `  ${GEN.serResult}[${JSON.stringify(property)}] = ${JSON.stringify(sub.name)};\n`;
-                    }
-                    code += `  ${GEN.outItem} = ${GEN.serResult};\n`;
-                }
-                code += `} else { ${GEN.outItem} = ` + itemVar + '; }\n';
-                return code;
-            };
-            if (hasEach) {
-                const awaitKw = isAsync ? 'await ' : '';
-                if (isAsync) {
-                    nestedCode = `${outputTarget} = await Promise.all(${fieldVal}.map(async function(__ser_item) {\n`;
-                }
-                else {
-                    nestedCode = `var ${GEN.discArr} = [];\n`;
-                    nestedCode += `  for (var ${GEN.discIdx}=0; ${GEN.discIdx}<${fieldVal}.length; ${GEN.discIdx}++) {\n`;
-                    nestedCode += `    var __ser_item = ${fieldVal}[${GEN.discIdx}];\n`;
-                }
-                nestedCode += `    var ${GEN.outItem};\n`;
-                nestedCode += buildInstanceofChain('__ser_item', awaitKw);
-                if (isAsync) {
-                    nestedCode += `  return ${GEN.outItem};\n`;
-                    nestedCode += `}));`;
-                }
-                else {
-                    nestedCode += `    ${GEN.discArr}.push(${GEN.outItem});\n`;
-                    nestedCode += `  }\n`;
-                    nestedCode += `  ${outputTarget} = ${GEN.discArr};`;
-                }
-            }
-            else {
-                const awaitKw = isAsync ? 'await ' : '';
-                nestedCode = `var ${GEN.outItem};\n`;
-                nestedCode += buildInstanceofChain(fieldVal, awaitKw);
-                nestedCode += `${outputTarget} = ${GEN.outItem};`;
-            }
-        }
-        else {
-            // Existing simple nested logic
-            const nestedCls = meta.type.resolvedClass ?? meta.type.fn();
-            const nestedSealed = getSealed(nestedCls);
-            const execIdx = execs.length;
-            execs.push(nestedSealed);
-            if (hasEach) {
-                if (isAsync) {
-                    nestedCode = `${outputTarget} = await Promise.all(${fieldVal}.map(async function(__ser_item) { return __ser_item == null ? __ser_item : await execs[${execIdx}].serialize(__ser_item, opts); }));`;
-                }
-                else {
-                    nestedCode = `var ${GEN.nestedArr} = [];\n`;
-                    nestedCode += `  for (var ${GEN.nestedIdx}=0; ${GEN.nestedIdx}<${fieldVal}.length; ${GEN.nestedIdx}++) {\n`;
-                    nestedCode += `    var ${GEN.nestedItem} = ${fieldVal}[${GEN.nestedIdx}];\n`;
-                    nestedCode += `    ${GEN.nestedArr}.push(${GEN.nestedItem} == null ? ${GEN.nestedItem} : execs[${execIdx}].serialize(${GEN.nestedItem}, opts));\n`;
-                    nestedCode += `  }\n`;
-                    nestedCode += `  ${outputTarget} = ${GEN.nestedArr};`;
-                }
-            }
-            else {
-                const awaitKw = isAsync ? 'await ' : '';
-                nestedCode = `${outputTarget} = ${awaitKw}execs[${execIdx}].serialize(${fieldVal}, opts);`;
-            }
-        }
-        // Apply serialize transforms after nested serialize (nested serialize → transform)
-        nestedCode += buildPostNestedTransformCode(outputTarget, fieldKey, serTransforms, refs);
-        if (useOptionalGuard) {
-            innerCode = `if (${fieldVal} !== undefined && ${fieldVal} !== null) {\n  ${nestedCode}\n} else if (${fieldVal} === null) {\n  ${outputTarget} = null;\n}\n`;
-        }
-        else {
-            innerCode = `if (${fieldVal} != null) {\n  ${nestedCode}\n} else {\n  ${outputTarget} = ${fieldVal};\n}\n`;
-        }
-    }
-    else {
-        // Existing @Transform or direct assign handling
-        const outputExpr = buildSerializeOutputExpr(fieldKey, outputKey, fieldVal, meta, refs);
-        if (useOptionalGuard) {
-            innerCode += `if (${fieldVal} !== undefined) {\n`;
-            innerCode += '  ' + outputExpr + '\n';
-            innerCode += '}\n';
-        }
-        else {
-            innerCode += outputExpr + '\n';
-        }
-    }
-    fieldCode += fieldStart + innerCode + fieldEnd;
-    return fieldCode;
-}
-/**
- * Build field output expression.
- * If @Transform exists, call refs[i](params); otherwise, direct assignment.
- */
-function buildSerializeOutputExpr(fieldKey, outputKey, fieldValueExpr, meta, refs) {
-    const outputTarget = `${GEN.out}[${JSON.stringify(outputKey)}]`;
-    const serTransforms = meta.transform.filter(td => !td.options?.deserializeOnly);
-    if (serTransforms.length > 0) {
-        const transformed = buildSerializeTransformExpr(fieldValueExpr, fieldKey, serTransforms, refs);
-        return `${outputTarget} = ${transformed};`;
-    }
-    return `${outputTarget} = ${fieldValueExpr};`;
-}
-export { buildSerializeCode };
+`}else{const X=f(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};

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

@@ -1,61 +1 @@
-import { BakerError } from '../errors.js';
-import { hasRawOwn } from '../meta-access.js';
-/**
- * @internal — seal-time invariant checks invoked from sealOne after merge + type normalization,
- * before codegen. Throws BakerError on the first violation.
- *
- * Covers W2 (D7 + D9):
- * - Discriminator shape: empty subTypes / invalid subType entry / name collision / missing property
- * - Set/Map pairing: Set without setValue, Map without mapValue, setValue/mapValue target missing @Field metadata
- * - async-in-sync: a DTO that mixes async rules/transforms with sync rules/transforms in such a way
- *   that the caller cannot easily tell — this throws BakerError so the user makes the intent explicit.
- *   (Per W2 decision: throw, not warn.)
- */
-export function validateMeta(Class, merged) {
-    const className = Class.name;
-    for (const [key, meta] of Object.entries(merged)) {
-        // ─── Discriminator shape ─────────────────────────────────────────────
-        if (meta.type?.discriminator) {
-            const disc = meta.type.discriminator;
-            if (typeof disc.property !== 'string' || disc.property.length === 0) {
-                throw new BakerError(`${className}.${key}: discriminator.property must be a non-empty string.`);
-            }
-            if (!Array.isArray(disc.subTypes) || disc.subTypes.length === 0) {
-                throw new BakerError(`${className}.${key}: discriminator.subTypes must be a non-empty array of { value, name } entries.`);
-            }
-            const seenNames = new Set();
-            for (let i = 0; i < disc.subTypes.length; i++) {
-                const sub = disc.subTypes[i];
-                if (typeof sub.name !== 'string' || sub.name.length === 0) {
-                    throw new BakerError(`${className}.${key}: discriminator.subTypes[${i}].name must be a non-empty string.`);
-                }
-                if (typeof sub.value !== 'function') {
-                    throw new BakerError(`${className}.${key}: discriminator.subTypes[${i}].value must be a class constructor (got ${typeof sub.value}).`);
-                }
-                if (seenNames.has(sub.name)) {
-                    throw new BakerError(`${className}.${key}: discriminator.subTypes has duplicate name '${sub.name}'. Each subType must have a unique name.`);
-                }
-                seenNames.add(sub.name);
-                // subType class must have @Field metadata (RAW) — otherwise codegen will fail with a less clear error
-                if (!hasRawOwn(sub.value)) {
-                    throw new BakerError(`${className}.${key}: discriminator.subTypes[${i}].value (${sub.value.name}) has no @Field decorators.`);
-                }
-            }
-        }
-        // ─── Set/Map collection pairing — unified single-pass check ──────────
-        const collection = meta.type?.collection;
-        if (collection !== undefined && meta.type?.resolvedCollectionValue) {
-            const target = meta.type.resolvedCollectionValue;
-            if (!hasRawOwn(target)) {
-                const accessor = collection === 'Set' ? 'setValue' : 'mapValue';
-                throw new BakerError(`${className}.${key}: ${accessor} target (${target.name}) has no @Field decorators.`);
-            }
-        }
-    }
-    // ─── async-in-sync: D9 ────────────────────────────────────────────────
-    // Seal-time strict check for "mixed sync/async rules" was attempted but produces too many
-    // false positives — sync rules + async transform is a common, valid baker pattern. The
-    // remediation for D9 lives in W14's strict API: `validateSync(AsyncDto, x)` and the other
-    // `*Sync` variants throw BakerError at the call site after consulting `isAsync`/`isSerializeAsync`.
-    // No seal-time invariant added here.
-}
+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.`)}}}

package/dist/src/symbols.js

@@ -1,13 +1 @@
-/**
- * 2 Symbols — zero external storage, zero global pollution
- * Uses Symbol.for: allows AOT code and runtime code to share the same Symbol via the global registry
- */
-// TC39 decorator metadata polyfill. Bun 1.3.13 does not yet expose Symbol.metadata natively,
-// so this defines it; the `??=` guard yields to a native value if a future runtime provides one.
-// Must run before any decorated class is evaluated — symbols.ts sits at the root of the
-// metadata import graph, so it always does.
-Symbol.metadata ??= Symbol.for('Symbol.metadata');
-/** Tier 1 collection metadata (stored on Class[Symbol.metadata] by decorators) */
-export const RAW = Symbol.for('baker:raw');
-/** Tier 2 seal result (dual executor stored on Class by seal()) */
-export const SEALED = Symbol.for('baker:sealed');
+Symbol.metadata??=Symbol.for("Symbol.metadata");export const RAW=Symbol.for("baker:raw");export const SEALED=Symbol.for("baker:sealed");

package/dist/src/transformers/collection.transformer.js

@@ -1,25 +1 @@
-export function csvTransformer(separator = ',') {
-    return {
-        deserialize: ({ value }) => (typeof value === 'string' ? value.split(separator) : value),
-        serialize: ({ value }) => (Array.isArray(value) ? value.join(separator) : value),
-    };
-}
-export const jsonTransformer = {
-    deserialize: ({ value }) => {
-        if (typeof value !== 'string') {
-            return value;
-        }
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return value;
-        }
-    },
-    serialize: ({ value }) => {
-        if (value != null && typeof value === 'object') {
-            return JSON.stringify(value);
-        }
-        return value;
-    },
-};
+export function csvTransformer(r=","){return{deserialize:({value:t})=>typeof t==="string"?t.split(r):t,serialize:({value:t})=>Array.isArray(t)?t.join(r):t}}export const jsonTransformer={deserialize:({value:r})=>{if(typeof r!=="string")return r;try{return JSON.parse(r)}catch{return r}},serialize:({value:r})=>{if(r!=null&&typeof r==="object")return JSON.stringify(r);return r}};

package/dist/src/transformers/date.transformer.js

@@ -1,18 +1 @@
-export const unixSecondsTransformer = {
-    deserialize: ({ value }) => (typeof value === 'number' ? new Date(value * 1000) : value),
-    serialize: ({ value }) => (value instanceof Date ? Math.floor(value.getTime() / 1000) : value),
-};
-export const unixMillisTransformer = {
-    deserialize: ({ value }) => (typeof value === 'number' ? new Date(value) : value),
-    serialize: ({ value }) => (value instanceof Date ? value.getTime() : value),
-};
-export const isoStringTransformer = {
-    deserialize: ({ value }) => {
-        if (typeof value !== 'string') {
-            return value;
-        }
-        const d = new Date(value);
-        return Number.isNaN(d.getTime()) ? value : d;
-    },
-    serialize: ({ value }) => (value instanceof Date ? value.toISOString() : value),
-};
+export const unixSecondsTransformer={deserialize:({value:r})=>typeof r==="number"?new Date(r*1000):r,serialize:({value:r})=>r instanceof Date?Math.floor(r.getTime()/1000):r};export const unixMillisTransformer={deserialize:({value:r})=>typeof r==="number"?new Date(r):r,serialize:({value:r})=>r instanceof Date?r.getTime():r};export const isoStringTransformer={deserialize:({value:r})=>{if(typeof r!=="string")return r;const e=new Date(r);return Number.isNaN(e.getTime())?r:e},serialize:({value:r})=>r instanceof Date?r.toISOString():r};

package/dist/src/transformers/index.js

@@ -1,6 +1 @@
-export { trimTransformer, toLowerCaseTransformer, toUpperCaseTransformer } from './string.transformer.js';
-export { roundTransformer } from './number.transformer.js';
-export { unixSecondsTransformer, unixMillisTransformer, isoStringTransformer } from './date.transformer.js';
-export { csvTransformer, jsonTransformer } from './collection.transformer.js';
-export { luxonTransformer } from './luxon.transformer.js';
-export { momentTransformer } from './moment.transformer.js';
+export{trimTransformer,toLowerCaseTransformer,toUpperCaseTransformer}from"./string.transformer.js";export{roundTransformer}from"./number.transformer.js";export{unixSecondsTransformer,unixMillisTransformer,isoStringTransformer}from"./date.transformer.js";export{csvTransformer,jsonTransformer}from"./collection.transformer.js";export{luxonTransformer}from"./luxon.transformer.js";export{momentTransformer}from"./moment.transformer.js";

package/dist/src/transformers/luxon.transformer.js

@@ -1,34 +1 @@
-import { BakerError } from '../errors.js';
-const LUXON_MISSING = "luxonTransformer requires the optional peer dependency 'luxon'. Install it with: bun add luxon";
-async function luxonTransformer(opts) {
-    let luxon;
-    try {
-        luxon = await import('luxon');
-    }
-    catch (e) {
-        throw new BakerError(LUXON_MISSING, { cause: e });
-    }
-    const { DateTime } = luxon;
-    const zone = opts?.zone ?? 'utc';
-    // Hoist format option once so the serialize closure doesn't re-read opts per call
-    const format = opts?.format;
-    return {
-        deserialize: ({ value }) => {
-            if (typeof value === 'string') {
-                return DateTime.fromISO(value, { zone });
-            }
-            if (value instanceof Date) {
-                return DateTime.fromJSDate(value, { zone });
-            }
-            return value;
-        },
-        serialize: ({ value }) => {
-            if (value && typeof value === 'object' && typeof value.toISO === 'function') {
-                const v = value;
-                return format ? v.toFormat(format) : v.toISO();
-            }
-            return value;
-        },
-    };
-}
-export { luxonTransformer };
+import{BakerError as C}from"../errors.js";const F="luxonTransformer requires the optional peer dependency 'luxon'. Install it with: bun add luxon";async function luxonTransformer(g){let j;try{j=await import("luxon")}catch(b){throw new C(F,{cause:b})}const{DateTime:q}=j,w=g?.zone??"utc",y=g?.format;return{deserialize:({value:b})=>{if(typeof b==="string")return q.fromISO(b,{zone:w});if(b instanceof Date)return q.fromJSDate(b,{zone:w});return b},serialize:({value:b})=>{if(b&&typeof b==="object"&&typeof b.toISO==="function"){const A=b;return y?A.toFormat(y):A.toISO()}return b}}}export{luxonTransformer};