@zipbul/baker 3.4.0 → 3.4.1

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

@@ -1,65 +1 @@
-import { BakerError } from '../errors.js';
-/**
- * Static validation of @Expose stacks (§4.1, §3.3)
- *
- * 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
- *          - both groups=[] (ungrouped) → overlap
- *          - both non-empty groups with intersection → overlap
- *          - one ungrouped + one grouped → no overlap (different scope)
- */
-function validateExposeStacks(merged, className) {
-    const prefix = className ? `${className}.` : '';
-    for (const [key, meta] of Object.entries(merged)) {
-        // ① single-entry check: deserializeOnly + serializeOnly cannot coexist
-        for (const exp of meta.expose) {
-            if (exp.deserializeOnly && exp.serializeOnly) {
-                throw new BakerError(`Invalid @Expose on field '${prefix}${key}': cannot have both deserializeOnly:true and serializeOnly:true on the same @Expose entry. Use separate @Expose decorators for each direction.`);
-            }
-            // Reserved output keys would corrupt the serialized object (e.g. a '__proto__' key sets the
-            // prototype instead of an own property) — reject them as wire names, matching banned field names.
-            if (exp.name === '__proto__' || exp.name === 'constructor' || exp.name === 'prototype') {
-                throw new BakerError(`Invalid @Field name on '${prefix}${key}': '${exp.name}' is a reserved property name and cannot be used as a serialized key.`);
-            }
-        }
-        // ② multi-entry check per direction
-        // deserialize direction: !serializeOnly (includes bidirectional + deserializeOnly)
-        const desEntries = meta.expose.filter(e => !e.serializeOnly);
-        // serialize direction: !deserializeOnly (includes bidirectional + serializeOnly)
-        const serEntries = meta.expose.filter(e => !e.deserializeOnly);
-        checkDirectionOverlap(prefix + key, desEntries, 'deserialize');
-        checkDirectionOverlap(prefix + key, serEntries, 'serialize');
-    }
-}
-/**
- * Check for groups overlap between each pair of @Expose entries within the same direction
- */
-function checkDirectionOverlap(key, entries, direction) {
-    for (let i = 0; i < entries.length; i++) {
-        for (let j = i + 1; j < entries.length; j++) {
-            const aGroups = entries[i].groups ?? [];
-            const bGroups = entries[j].groups ?? [];
-            if (groupsOverlap(aGroups, bGroups)) {
-                const bSet = new Set(bGroups);
-                const overlapping = aGroups.length === 0 ? [] : aGroups.filter(g => bSet.has(g));
-                throw new BakerError(`@Expose conflict on '${key}': 2 @Expose stacks with '${direction}' direction and overlapping groups [${overlapping.join(', ')}]. Each direction must have at most one @Expose per group set.`);
-            }
-        }
-    }
-}
-/**
- * Determine whether two groups arrays overlap.
- * - both empty → overlap (same ungrouped scope)
- * - both non-empty with intersection → overlap
- * - one empty + one non-empty → no overlap (different filter scopes)
- */
-function groupsOverlap(a, b) {
-    if (a.length === 0 && b.length === 0) {
-        return true;
-    }
-    if (a.length === 0 || b.length === 0) {
-        return false;
-    }
-    return a.some(g => b.includes(g));
-}
-export { validateExposeStacks };
+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};

package/dist/src/seal/seal-state.js

@@ -1,18 +1 @@
-/**
- * @internal — shared seal state, extracted so `configure.ts` can read `isSealed()`
- * without importing `seal.ts` (which would create a cycle: seal → configure → seal).
- */
-let sealed = false;
-/** List of sealed classes — used by unseal to remove SEALED */
-export const sealedClasses = new Set();
-export function isSealed() {
-    return sealed;
-}
-export function markSealed() {
-    sealed = true;
-}
-/** @internal — used by unseal() in test helpers */
-export function resetForTesting() {
-    sealed = false;
-    sealedClasses.clear();
-}
+let c=!1;export const sealedClasses=new Set;export function isSealed(){return c}export function markSealed(){c=!0}export function resetForTesting(){c=!1;sealedClasses.clear()}

package/dist/src/seal/seal.js

@@ -1,431 +1 @@
-import { getGlobalOptions } from '../configure.js';
-import { BakerError } from '../errors.js';
-import { deleteSealed, freezeRaw, getRaw, getSealed, hasRawOwn, hasSealedOwn, setSealed } from '../meta-access.js';
-import { globalRegistry } from '../registry.js';
-import { isAsyncFunction } from '../utils.js';
-import { analyzeCircular } from './circular-analyzer.js';
-import { buildDeserializeCode, buildValidateCode } from './deserialize-builder.js';
-import { validateExposeStacks } from './expose-validator.js';
-import { sealedClasses, isSealed, markSealed } from './seal-state.js';
-import { buildSerializeCode } from './serialize-builder.js';
-import { validateMeta } from './validate-meta.js';
-const BANNED_FIELD_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
-const PRIMITIVE_CTORS = new Set([Number, String, Boolean, Date]);
-/** @internal Placeholder executor for circular dependency detection during seal */
-function circularPlaceholder(className) {
-    const msg = `Circular dependency during seal: ${className} is still being sealed`;
-    return {
-        deserialize() {
-            throw new BakerError(msg);
-        },
-        serialize() {
-            throw new BakerError(msg);
-        },
-        validate() {
-            throw new BakerError(msg);
-        },
-        isAsync: false,
-        isSerializeAsync: false,
-    };
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// analyzeAsync — static analysis to determine if a sealed DTO requires an async executor (C1)
-// ─────────────────────────────────────────────────────────────────────────────
-function analyzeAsync(merged, direction, visited) {
-    const flag = direction === 'deserialize' ? 'isAsync' : 'isSerializeAsync';
-    const seen = visited ?? new Set();
-    // sealOne seals every nested DTO (step 4) before this runs (step 5). For a fully-sealed nested
-    // class its `isAsync`/`isSerializeAsync` flag is authoritative and already accounts for ITS nested
-    // classes — so trusting the flag propagates async through any nesting depth (re-deriving from
-    // metadata would lose `resolvedClass` past depth 1). A class still being sealed carries a
-    // placeholder executor (no `merged`); that only happens on a circular back-edge, where the flag
-    // is not yet known — there we recurse into the class's own metadata, guarded by `seen`.
-    const nestedIsAsync = (cls) => {
-        if (seen.has(cls)) {
-            return false;
-        }
-        seen.add(cls);
-        const sealed = getSealed(cls);
-        if (sealed?.merged) {
-            return sealed[flag] === true;
-        }
-        return analyzeAsync(mergeInheritance(cls), direction, seen);
-    };
-    for (const meta of Object.values(merged)) {
-        // 1. createRule may return Promise<boolean> even without `async` syntax (deserialize only).
-        if (direction === 'deserialize' && meta.validation.some(rd => rd.rule.isAsync)) {
-            return true;
-        }
-        // 2. @Transform async — single-pass scan, avoids intermediate filter[] allocation
-        for (const td of meta.transform) {
-            if (direction === 'deserialize' ? td.options?.serializeOnly : td.options?.deserializeOnly) {
-                continue;
-            }
-            if (td.isAsync ?? isAsyncFunction(td.fn)) {
-                return true;
-            }
-        }
-        // 3. nested DTOs (direct, Set/Map value, discriminator subtypes)
-        if (nestedClassesOf(meta).some(nestedIsAsync)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Nested DTO classes referenced by a field's type. Prefers normalized `resolved*` slots, but
- * falls back to resolving the raw `type.fn()` thunk — needed when `analyzeAsync` recurses into a
- * still-being-sealed class on a circular back-edge whose metadata was never normalized.
- */
-function nestedClassesOf(meta) {
-    const t = meta.type;
-    if (!t) {
-        return [];
-    }
-    const out = [];
-    if (t.resolvedClass) {
-        out.push(t.resolvedClass);
-    }
-    if (t.resolvedCollectionValue) {
-        out.push(t.resolvedCollectionValue);
-    }
-    if (t.discriminator) {
-        for (const sub of t.discriminator.subTypes) {
-            out.push(sub.value);
-        }
-    }
-    if (out.length === 0 && t.fn) {
-        const result = t.fn();
-        if (result === Map || result === Set) {
-            const cv = t.collectionValue?.();
-            if (typeof cv === 'function' && !PRIMITIVE_CTORS.has(cv)) {
-                out.push(cv);
-            }
-        }
-        else {
-            const resolved = Array.isArray(result) ? result[0] : result;
-            if (typeof resolved === 'function' && !PRIMITIVE_CTORS.has(resolved)) {
-                out.push(resolved);
-            }
-        }
-    }
-    return out;
-}
-// Seal state lives in ./seal-state so `configure.ts` can read it without importing this file
-// (which would form a cycle: seal → configure → seal). Re-export the test helpers used by `unseal()`.
-/**
- * @internal — used by serialize/deserialize. Returns the sealed executor.
- * Throws if the class was never sealed. Users must call `seal()` at app startup.
- */
-function ensureSealed(Class) {
-    const sealed = getSealed(Class);
-    if (!sealed) {
-        const name = Class.name || '<anonymous class>';
-        throw new BakerError(`${name} is not sealed. Call seal() at app startup before deserialize/validate/serialize. ` +
-            `(If ${name} has no @Field decorators, decorate at least one property.)`);
-    }
-    return sealed;
-}
-/**
- * Seal every class in the decorator registry, then clear the registry.
- */
-function sealAllRegistered() {
-    if (isSealed()) {
-        return;
-    }
-    const options = getGlobalOptions();
-    const sealed = new Set();
-    try {
-        for (const Class of globalRegistry) {
-            sealOne(Class, options, sealed);
-        }
-    }
-    catch (e) {
-        // On failure, roll back every class sealed so far (including nested DTOs) — prevent
-        // partial seal state. The failed class self-cleaned its own placeholder in sealOne.
-        for (const Class of sealed) {
-            deleteSealed(Class);
-        }
-        throw e;
-    }
-    for (const Class of sealed) {
-        sealedClasses.add(Class);
-        freezeRaw(Class);
-    }
-    globalRegistry.clear();
-    markSealed();
-}
-/**
- * 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
- * isolation. Class[Symbol.metadata][RAW] must exist; Class[SEALED] must not.
- * Transactional: on failure, every placeholder installed by this call (the class and any
- * nested DTO reached by recursion) is removed so a future seal attempt can re-run cleanly.
- */
-function sealOneClass(Class) {
-    if (hasSealedOwn(Class)) {
-        return;
-    }
-    const options = getGlobalOptions();
-    const sealed = new Set();
-    try {
-        sealOne(Class, options, sealed);
-    }
-    catch (e) {
-        // Roll back every class sealed during this call (the failed class self-cleaned in sealOne).
-        for (const C of sealed) {
-            deleteSealed(C);
-        }
-        throw e;
-    }
-    // Freeze + track + drop from the registry every class sealed by this call (incl. nested).
-    for (const C of sealed) {
-        sealedClasses.add(C);
-        freezeRaw(C);
-        globalRegistry.delete(C);
-    }
-}
-/**
- * Public — call once at app startup. Seals every @Recipe-decorated class (and its nested DTOs)
- * and clears the registry. Idempotent: a second call is a no-op.
- *
- * Baker requires this call before any deserialize/serialize/validate. There is no implicit seal.
- * All DTOs must be imported before this call — baker has no lazy/on-demand sealing.
- */
-function seal() {
-    sealAllRegistered();
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// sealOne() — seal an individual class (§4.1)
-// ─────────────────────────────────────────────────────────────────────────────
-function sealOne(Class, options, sealedAcc) {
-    if (hasSealedOwn(Class)) {
-        return;
-    } // already sealed (prevent recursion during circular references)
-    // 0. Register placeholder — prevent infinite recursion on circular references
-    const placeholder = circularPlaceholder(Class.name);
-    setSealed(Class, placeholder);
-    try {
-        // 1. Merge inheritance metadata
-        const merged = mergeInheritance(Class);
-        // 1a. Banned field name check — prevent prototype pollution (C5)
-        for (const key of Object.keys(merged)) {
-            if (BANNED_FIELD_NAMES.has(key)) {
-                throw new BakerError(`${Class.name}: field name '${key}' is not allowed (reserved property name)`);
-            }
-        }
-        // 1b. TypeDef normalization — resolve @Type/@Field type fn(), detect arrays, auto-infer nested DTOs
-        //     Prevent original RAW mutation: copy type/flags before mutating (C-16 root fix)
-        for (const [key, meta] of Object.entries(merged)) {
-            if (!meta.type?.fn) {
-                continue;
-            }
-            let typeResult;
-            try {
-                typeResult = meta.type.fn();
-            }
-            catch (e) {
-                throw new BakerError(`${Class.name}.${key}: type function threw: ${e.message}`, { cause: e });
-            }
-            // Detect Map/Set collection
-            if (typeResult === Map || typeResult === Set) {
-                const collection = typeResult === Map ? 'Map' : 'Set';
-                const typeCopy = { ...meta.type, collection, isArray: false };
-                // collectionValue thunk → cache resolvedCollectionValue
-                if (meta.type.collectionValue) {
-                    let valCls;
-                    try {
-                        valCls = meta.type.collectionValue();
-                    }
-                    catch (e) {
-                        throw new BakerError(`${Class.name}.${key}: collectionValue function threw: ${e.message}`, { cause: e });
-                    }
-                    if (valCls != null && typeof valCls === 'function' && !PRIMITIVE_CTORS.has(valCls)) {
-                        typeCopy.resolvedCollectionValue = valCls;
-                    }
-                }
-                merged[key] = { ...meta, type: typeCopy };
-                continue;
-            }
-            const isArray = Array.isArray(typeResult);
-            const resolved = isArray ? typeResult[0] : typeResult;
-            if (resolved == null || typeof resolved !== 'function') {
-                throw new BakerError(`${Class.name}: @Type/@Field type must return a constructor or [constructor], got ${String(resolved)}`);
-            }
-            // Copy type object before mutating — preserve original RAW type reference
-            const typeCopy = { ...meta.type, isArray };
-            if (!PRIMITIVE_CTORS.has(resolved)) {
-                typeCopy.resolvedClass = resolved;
-                // Automatically set validateNested flags for DTO classes
-                if (!meta.flags.validateNested || !meta.flags.validateNestedEach) {
-                    meta.flags = { ...meta.flags };
-                    if (!meta.flags.validateNested) {
-                        meta.flags.validateNested = true;
-                    }
-                    if (isArray && !meta.flags.validateNestedEach) {
-                        meta.flags.validateNestedEach = true;
-                    }
-                }
-            }
-            merged[key] = { ...meta, type: typeCopy };
-        }
-        // 2. Static validation of @Expose stacks (throws BakerError on failure)
-        validateExposeStacks(merged, Class.name);
-        // 2b. W2: seal-time invariant checks (D7 discriminator/Set·Map + D9 async-in-sync)
-        validateMeta(Class, merged);
-        // 3. Static analysis for circular references
-        const needsCircularCheck = analyzeCircular(Class);
-        // 4. Seal nested @Type referenced DTOs first (recursive) — uses resolvedClass / resolvedCollectionValue
-        for (const meta of Object.values(merged)) {
-            if (meta.type?.resolvedClass) {
-                sealOne(meta.type.resolvedClass, options, sealedAcc);
-            }
-            if (meta.type?.resolvedCollectionValue) {
-                sealOne(meta.type.resolvedCollectionValue, options, sealedAcc);
-            }
-            if (meta.type?.discriminator) {
-                for (const sub of meta.type.discriminator.subTypes) {
-                    sealOne(sub.value, options, sealedAcc);
-                }
-            }
-        }
-        // 5. Async analysis
-        const isAsync = analyzeAsync(merged, 'deserialize');
-        const isSerializeAsync = analyzeAsync(merged, 'serialize');
-        // 6. Generate deserialize executor code
-        const deserializeExecutor = buildDeserializeCode(Class, merged, options, needsCircularCheck, isAsync);
-        // 6b. Generate validate-only executor code (no Object.create, no assignments)
-        const validateExecutor = buildValidateCode(Class, merged, options, needsCircularCheck, isAsync);
-        // 7. Generate serialize executor code
-        const serializeExecutor = buildSerializeCode(Class, merged, options, isSerializeAsync);
-        // 8. Replace placeholder with actual executor in-place (Object.assign preserves reference integrity)
-        Object.assign(placeholder, {
-            deserialize: deserializeExecutor,
-            serialize: serializeExecutor,
-            validate: validateExecutor,
-            isAsync: isAsync,
-            isSerializeAsync: isSerializeAsync,
-            merged: merged,
-        });
-    }
-    catch (e) {
-        // Self-clean this class's placeholder so a failed seal leaves no broken state —
-        // including nested DTOs reached by recursion that are not in the registry.
-        deleteSealed(Class);
-        throw e;
-    }
-    // Record success so the caller can freeze + track every sealed class (including nested
-    // DTOs reached by recursion) once the whole operation succeeds. Freezing here would be
-    // premature: a later failure must roll back, and a frozen RAW cannot be re-sealed.
-    sealedAcc?.add(Class);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// mergeInheritance() — merge inheritance metadata (§4.2)
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * 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
- */
-function mergeInheritance(Class) {
-    // Collect classes with RAW along the prototype chain (array order: child first)
-    const chain = [];
-    let current = Class;
-    while (current && current !== Object) {
-        if (hasRawOwn(current)) {
-            chain.push(current);
-        }
-        const proto = Object.getPrototypeOf(current);
-        current = proto === current ? null : proto;
-    }
-    // child-first merge
-    const merged = Object.create(null);
-    // When the prototype chain has only the class itself (no decorated parent), no merging happens
-    // and we never mutate the metadata arrays — skip the shallow copy entirely.
-    const needsCopy = chain.length > 1;
-    for (const ctor of chain) {
-        const raw = getRaw(ctor);
-        for (const [key, meta] of Object.entries(raw)) {
-            if (!merged[key]) {
-                // First occurrence of field → copy only when subsequent ancestors might mutate
-                merged[key] = needsCopy
-                    ? {
-                        validation: [...meta.validation],
-                        transform: [...meta.transform],
-                        expose: [...meta.expose],
-                        exclude: meta.exclude,
-                        type: meta.type,
-                        flags: { ...meta.flags },
-                    }
-                    : meta;
-            }
-            else {
-                // Already exists in child → independent merge per category (§4.2)
-                const m = merged[key];
-                const p = meta;
-                // validation: union merge by ruleName — child overrides parent for the same rule name (N-6)
-                for (const rd of p.validation) {
-                    if (!m.validation.some(d => d.rule.ruleName === rd.rule.ruleName)) {
-                        m.validation.push(rd);
-                    }
-                }
-                // transform: inherit from parent if absent in child
-                if (m.transform.length === 0 && p.transform.length > 0) {
-                    m.transform = [...p.transform];
-                }
-                // expose: inherit from parent if absent in child
-                if (m.expose.length === 0 && p.expose.length > 0) {
-                    m.expose = [...p.expose];
-                }
-                // exclude: inherit from parent if absent in child
-                if (m.exclude === null && p.exclude !== null) {
-                    m.exclude = p.exclude;
-                }
-                // type: inherit from parent if absent in child
-                if (m.type === null && p.type !== null) {
-                    m.type = p.type;
-                }
-                // flags: child takes priority, only supplement missing flags from parent
-                const mf = m.flags;
-                const pf = p.flags;
-                if (pf.isOptional !== undefined && mf.isOptional === undefined) {
-                    mf.isOptional = pf.isOptional;
-                }
-                if (pf.isDefined !== undefined && mf.isDefined === undefined) {
-                    mf.isDefined = pf.isDefined;
-                }
-                if (pf.validateIf !== undefined && mf.validateIf === undefined) {
-                    mf.validateIf = pf.validateIf;
-                }
-                if (pf.isNullable !== undefined && mf.isNullable === undefined) {
-                    mf.isNullable = pf.isNullable;
-                }
-                if (pf.validateNested !== undefined && mf.validateNested === undefined) {
-                    mf.validateNested = pf.validateNested;
-                }
-                if (pf.validateNestedEach !== undefined && mf.validateNestedEach === undefined) {
-                    mf.validateNestedEach = pf.validateNestedEach;
-                }
-            }
-        }
-    }
-    return merged;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// __testing__ — test-only export (TST-ACCESS compliant)
-// ─────────────────────────────────────────────────────────────────────────────
-const __testing__ = {
-    mergeInheritance,
-    circularPlaceholder,
-    // Targeted single-class seal — test-only. Production code uses argless seal() exclusively;
-    // this exists so tests can seal one class in isolation (e.g. error-path assertions).
-    sealClass: sealOneClass,
-};
-export { ensureSealed, seal, mergeInheritance, __testing__ };
-export { sealedClasses, resetForTesting } from './seal-state.js';
+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";