@zipbul/baker 3.4.0 → 4.0.0

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

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

package/dist/src/seal/enums.js

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

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

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

package/dist/src/seal/seal-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.d.ts

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

package/dist/src/seal/seal.js

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