@webergency-utils/typechecker 0.1.9 → 0.2.1

package/dist/runtime/validators.js

@@ -2,133 +2,519 @@ const report = (ctx, path, expected, value, message) => {
     ctx.success = false;
     ctx.errors.push({ path, value, error: message || expected });
 };
+function isPlainObject(v) {
+    if (v === null || typeof v !== 'object' || Array.isArray(v)) {
+        return false;
+    }
+    if (v instanceof Date || v instanceof RegExp || v instanceof Map || v instanceof Set) {
+        return false;
+    }
+    if (typeof Buffer !== 'undefined' && typeof Buffer.isBuffer === 'function' && Buffer.isBuffer(v)) {
+        return false;
+    }
+    if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+function testRegex(regex, value) {
+    if (!regex.global && !regex.sticky) {
+        return regex.test(value);
+    }
+    const copy = new RegExp(regex.source, regex.flags);
+    return copy.test(value);
+}
+function isMultipleOfNumber(v, n) {
+    if (n === 0 || !Number.isFinite(n)) {
+        return false;
+    }
+    if (!Number.isFinite(v)) {
+        return true;
+    }
+    const q = v / n;
+    return Math.abs(q - Math.round(q)) <= 1e-8 * Math.max(1, Math.abs(q));
+}
+function shouldMutate(ctx) {
+    return ctx.mutate === true;
+}
+function wantsQuery(ctx) {
+    return ctx.from === 'query';
+}
+function wantsJsonRevive(ctx) {
+    return ctx.from === 'json' || ctx.from === 'query';
+}
+function pathKey(path) {
+    if (!path) {
+        return '';
+    }
+    const bracket = path.lastIndexOf('[');
+    const dot = path.lastIndexOf('.');
+    if (bracket > dot) {
+        const end = path.lastIndexOf(']');
+        if (end > bracket) {
+            return path.slice(bracket + 1, end);
+        }
+    }
+    if (dot >= 0) {
+        return path.slice(dot + 1);
+    }
+    return path;
+}
+function fromCustom(ctx, path, value, type) {
+    if (typeof ctx.from !== 'function') {
+        return value;
+    }
+    return ctx.from(pathKey(path), value, type);
+}
+/** Query-style number coercion — shared by `from: 'query'` and `transform.ToNumber`. */
+export function coerceQueryNumber(v) {
+    if (typeof v === 'number') {
+        return v;
+    }
+    if (typeof v === 'string' && v.trim() !== '') {
+        const parsed = parseFloat(v);
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return v;
+}
+/** Query-style boolean coercion — shared by `from: 'query'` and `transform.ToBoolean`. */
+export function coerceQueryBoolean(v) {
+    if (typeof v === 'boolean') {
+        return v;
+    }
+    if (typeof v === 'string' || typeof v === 'number') {
+        const s = String(v).toLowerCase();
+        if (s === 'true' || s === '1' || s === 'yes' || s === 'on') {
+            return true;
+        }
+        if (s === 'false' || s === '0' || s === 'no' || s === 'off') {
+            return false;
+        }
+    }
+    return v;
+}
+/** JSON-wire Date revival (ISO / date-parseable strings only). */
+export function coerceJsonDate(v) {
+    if (v instanceof Date && !Number.isNaN(v.getTime())) {
+        return v;
+    }
+    if (typeof v === 'string') {
+        const parsed = new Date(v);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+    }
+    return v;
+}
+/** Query-style Date coercion — shared by `from: 'query'` and `transform.ToDate`. */
+export function coerceQueryDate(v) {
+    const fromJson = coerceJsonDate(v);
+    if (fromJson !== v) {
+        return fromJson;
+    }
+    if (v instanceof Date && !Number.isNaN(v.getTime())) {
+        return v;
+    }
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        const parsed = new Date(v);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+    }
+    return v;
+}
+const EMAIL_LOCAL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+$/;
+const EMAIL_DOMAIN_RE = /^(?=.{1,253}$)(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,63}$/i;
+const IDN_EMAIL_LOCAL_RE = /^[\p{L}\p{N}.!#$%&'*+/=?^_`{|}~-]+$/u;
+const IDN_EMAIL_DOMAIN_RE = /^(?=.{1,253}$)(?:(?!-)[\p{L}\p{N}-]{1,63}(?<!-)\.)+[\p{L}]{2,63}$/u;
+const HOSTNAME_RE = /^(?=.{1,253}$)(?:localhost|(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,63})$/i;
+const IDN_HOSTNAME_RE = /^(?=.{1,253}$)(?:localhost|(?:(?!-)[\p{L}\p{N}-]{1,63}(?<!-)\.)+[\p{L}]{2,63})$/iu;
+const URI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s<>"{}|\\^`]*$/;
+const IRI_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\S+$/u;
+const URI_TEMPLATE_RE = /^(?:[^{}\s]|\{[+#./;?&=,!@|]?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})(?:\.?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2}))*(?::[1-9]\d{0,3}|\*)?(?:,(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})(?:\.?(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2}))*(?::[1-9]\d{0,3}|\*)?)*\})+$/;
+function isEmail(value) {
+    if (value.length > 254) {
+        return false;
+    }
+    const at = value.lastIndexOf('@');
+    if (at < 1 || at !== value.indexOf('@') || at === value.length - 1) {
+        return false;
+    }
+    const local = value.slice(0, at);
+    const domain = value.slice(at + 1);
+    if (local.length > 64) {
+        return false;
+    }
+    if (local.startsWith('.') || local.endsWith('.') || local.includes('..')) {
+        return false;
+    }
+    if (!EMAIL_LOCAL_RE.test(local)) {
+        return false;
+    }
+    if (!EMAIL_DOMAIN_RE.test(domain)) {
+        return false;
+    }
+    return true;
+}
+function isIdnEmail(value) {
+    if (value.length > 254) {
+        return false;
+    }
+    const at = value.lastIndexOf('@');
+    if (at < 1 || at !== value.indexOf('@') || at === value.length - 1) {
+        return false;
+    }
+    const local = value.slice(0, at);
+    const domain = value.slice(at + 1);
+    if (local.length > 64) {
+        return false;
+    }
+    if (local.startsWith('.') || local.endsWith('.') || local.includes('..')) {
+        return false;
+    }
+    if (!IDN_EMAIL_LOCAL_RE.test(local)) {
+        return false;
+    }
+    if (!IDN_EMAIL_DOMAIN_RE.test(domain)) {
+        return false;
+    }
+    return true;
+}
+function isHostname(value) {
+    return HOSTNAME_RE.test(value);
+}
+function isIdnHostname(value) {
+    return IDN_HOSTNAME_RE.test(value);
+}
+function isUri(value) {
+    if (!URI_RE.test(value)) {
+        return false;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value);
+        return true;
+    }
+    catch {
+        // mailto:, urn:, and some other schemes are valid URIs but may throw in URL()
+        return /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s<>"{}|\\^`]+$/.test(value);
+    }
+}
+function isUriReference(value) {
+    if (value === '') {
+        return true;
+    }
+    if (isUri(value)) {
+        return true;
+    }
+    if (/[\s<>"{}|\\^`]/.test(value)) {
+        return false;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value, 'http://example.com');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isIri(value) {
+    if (!IRI_RE.test(value)) {
+        return false;
+    }
+    if (/[\u0000-\u001F\u007F]/.test(value)) {
+        return false;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value);
+        return true;
+    }
+    catch {
+        return /^[a-zA-Z][a-zA-Z0-9+.-]*:\S+$/u.test(value);
+    }
+}
+function isIriReference(value) {
+    if (value === '') {
+        return true;
+    }
+    if (isIri(value)) {
+        return true;
+    }
+    if (/\s|[\u0000-\u001F\u007F]/.test(value)) {
+        return false;
+    }
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value, 'http://example.com');
+        return true;
+    }
+    catch {
+        return /^[^<>"{}|\\^`]+$/u.test(value);
+    }
+}
+function isUriTemplate(value) {
+    if (!value || /\s/.test(value)) {
+        return false;
+    }
+    let depth = 0;
+    for (const ch of value) {
+        if (ch === '{') {
+            depth++;
+        }
+        else if (ch === '}') {
+            if (depth === 0) {
+                return false;
+            }
+            depth--;
+        }
+    }
+    if (depth !== 0) {
+        return false;
+    }
+    return URI_TEMPLATE_RE.test(value);
+}
+function parseFormatDate(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        return undefined;
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseFormatDateTime(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return undefined;
+    }
+    return parsed;
+}
+function stableStringify(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+    if (seen.has(value)) {
+        return undefined;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const parts = value.map(item => {
+            const s = stableStringify(item, seen);
+            return s === undefined ? '"[Circular]"' : s;
+        });
+        return `[${parts.join(',')}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const parts = keys.map(key => `${JSON.stringify(key)}:${stableStringify(value[key], seen) ?? '"[Circular]"'}`);
+    return `{${parts.join(',')}}`;
+}
 export const validators = {
+    coerceQueryNumber,
+    coerceQueryBoolean,
+    coerceQueryDate,
+    coerceJsonDate,
     string: (v, path, ctx) => {
-        if (typeof v !== 'string') {
-            report(ctx, path, 'Type<string>', v);
+        if (typeof v === 'string') {
+            return v;
         }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'string');
+            if (typeof converted === 'string') {
+                return converted;
+            }
+        }
+        report(ctx, path, 'Type<string>', v);
         return v;
     },
     number: (v, path, ctx) => {
-        if (typeof v !== 'number') {
-            if (ctx.tryConvert && typeof v === 'string' && v.trim() !== '') {
-                const parsed = parseFloat(v);
-                if (!isNaN(parsed)) {
-                    return parsed;
-                }
+        if (wantsQuery(ctx)) {
+            v = coerceQueryNumber(v);
+        }
+        if (typeof v === 'number') {
+            if (Number.isNaN(v)) {
+                report(ctx, path, 'Type<number>', v);
             }
-            report(ctx, path, 'Type<number>', v);
+            return v;
         }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'number');
+            if (typeof converted === 'number' && !Number.isNaN(converted)) {
+                return converted;
+            }
+        }
+        report(ctx, path, 'Type<number>', v);
         return v;
     },
     bigint: (v, path, ctx) => {
-        if (typeof v !== 'bigint') {
-            if (ctx.tryConvert && typeof v === 'string' && v.trim() !== '') {
-                try {
-                    return BigInt(v);
-                }
-                catch (e) { /* ignore */ }
+        if (typeof v === 'bigint') {
+            return v;
+        }
+        if (wantsJsonRevive(ctx) && typeof v === 'string' && v.trim() !== '') {
+            try {
+                return BigInt(v);
             }
-            report(ctx, path, 'Type<bigint>', v);
+            catch (e) { /* ignore */ }
         }
+        if (wantsQuery(ctx) && typeof v === 'number' && Number.isFinite(v) && Number.isInteger(v)) {
+            try {
+                return BigInt(v);
+            }
+            catch (e) { /* ignore */ }
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'bigint');
+            if (typeof converted === 'bigint') {
+                return converted;
+            }
+        }
+        report(ctx, path, 'Type<bigint>', v);
         return v;
     },
     boolean: (v, path, ctx) => {
-        if (typeof v !== 'boolean') {
-            if (ctx.tryConvert && (v === undefined || v === null)) {
-                return false;
+        if (wantsQuery(ctx)) {
+            v = coerceQueryBoolean(v);
+        }
+        if (typeof v === 'boolean') {
+            return v;
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'boolean');
+            if (typeof converted === 'boolean') {
+                return converted;
             }
-            if (ctx.tryConvert && (typeof v === 'string' || typeof v === 'number')) {
-                const s = String(v).toLowerCase();
-                if (s === 'true' || s === '1' || s === 'yes' || s === 'on') {
-                    return true;
-                }
-                if (s === 'false' || s === '0' || s === 'no' || s === 'off') {
-                    return false;
-                }
+        }
+        report(ctx, path, 'Type<boolean>', v);
+        return v;
+    },
+    function: (v, path, ctx) => {
+        if (typeof v === 'function') {
+            return v;
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'function');
+            if (typeof converted === 'function') {
+                return converted;
             }
-            report(ctx, path, 'Type<boolean>', v);
         }
+        report(ctx, path, 'Type<function>', v);
         return v;
     },
     date: (v, path, ctx) => {
-        if (!(v instanceof Date) || isNaN(v.getTime())) {
-            if (ctx.tryConvert && typeof v === 'string') {
-                const parsed = new Date(v);
-                if (!isNaN(parsed.getTime())) {
-                    return parsed;
-                }
+        if (wantsQuery(ctx)) {
+            v = coerceQueryDate(v);
+        }
+        else if (ctx.from === 'json') {
+            v = coerceJsonDate(v);
+        }
+        if (v instanceof Date && !Number.isNaN(v.getTime())) {
+            return v;
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'Date');
+            if (converted instanceof Date && !Number.isNaN(converted.getTime())) {
+                return converted;
             }
-            report(ctx, path, 'Type<Date>', v);
         }
+        report(ctx, path, 'Type<Date>', v);
         return v;
     },
     regexp: (v, path, ctx) => {
-        if (!(v instanceof RegExp)) {
-            if (ctx.tryConvert && typeof v === 'string') {
+        if (v instanceof RegExp) {
+            return v;
+        }
+        if (wantsJsonRevive(ctx)) {
+            if (typeof v === 'string') {
                 const match = v.match(/^\/(.*)\/([gimuy]*)$/);
                 if (match) {
                     try {
                         return new RegExp(match[1], match[2]);
                     }
-                    catch (e) { }
+                    catch (e) { /* fall through */ }
                 }
-                else {
+                else if (wantsQuery(ctx)) {
                     try {
                         return new RegExp(v);
                     }
-                    catch (e) { }
+                    catch (e) { /* fall through */ }
+                }
+            }
+            if (v && typeof v === 'object' && typeof v.source === 'string') {
+                try {
+                    return new RegExp(v.source, typeof v.flags === 'string' ? v.flags : '');
                 }
+                catch (e) { /* fall through */ }
+            }
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'RegExp');
+            if (converted instanceof RegExp) {
+                return converted;
             }
-            report(ctx, path, 'Type<RegExp>', v);
         }
+        report(ctx, path, 'Type<RegExp>', v);
         return v;
     },
     null: (v, path, ctx) => {
-        if (v !== null) {
-            report(ctx, path, 'Type<null>', v);
+        if (v === null) {
+            return null;
         }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'null');
+            if (converted === null) {
+                return null;
+            }
+        }
+        report(ctx, path, 'Type<null>', v);
         return null;
     },
     undefined: (v, path, ctx) => {
-        if (v !== undefined) {
-            report(ctx, path, 'Type<undefined>', v);
+        if (v === undefined) {
+            return undefined;
         }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'undefined');
+            if (converted === undefined) {
+                return undefined;
+            }
+        }
+        report(ctx, path, 'Type<undefined>', v);
         return undefined;
     },
     literal: (v, path, ctx, expected) => {
-        if (v !== expected) {
-            if (ctx.tryConvert && (v === undefined || v === null)) {
-                if (typeof expected === 'boolean') {
-                    if (expected === false) {
-                        return false;
-                    }
+        if (v === expected) {
+            return v;
+        }
+        if (wantsQuery(ctx)) {
+            if (typeof expected === 'number') {
+                const p = coerceQueryNumber(v);
+                if (p === expected) {
+                    return p;
                 }
             }
-            if (ctx.tryConvert && typeof v === 'string') {
-                if (typeof expected === 'number') {
-                    const p = parseFloat(v);
-                    if (p === expected) {
-                        return p;
-                    }
-                }
-                if (typeof expected === 'boolean') {
-                    const s = v.toLowerCase();
-                    let val;
-                    if (s === 'true' || s === '1' || s === 'yes' || s === 'on') {
-                        val = true;
-                    }
-                    else if (s === 'false' || s === '0' || s === 'no' || s === 'off') {
-                        val = false;
-                    }
-                    if (val === expected) {
-                        return val;
-                    }
+            if (typeof expected === 'boolean') {
+                const val = coerceQueryBoolean(v);
+                if (val === expected) {
+                    return val;
                 }
             }
-            const expStr = typeof expected === 'string' ? `'${expected}'` : expected;
-            report(ctx, path, `Literal<${expStr}>`, v);
         }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'literal');
+            if (converted === expected) {
+                return converted;
+            }
+        }
+        const expStr = typeof expected === 'string' ? `'${expected}'` : expected;
+        report(ctx, path, `Literal<${expStr}>`, v);
         return v;
     },
     array: (v, path, ctx, childValidator) => {
@@ -136,17 +522,26 @@ export const validators = {
             if (ctx.wrapArrays && v !== undefined && v !== null) {
                 v = [v];
             }
+            else if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'Array');
+                if (Array.isArray(converted)) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, 'Type<Array>', v);
+                    return v;
+                }
+            }
             else {
                 report(ctx, path, 'Type<Array>', v);
                 return v;
             }
         }
-        const data = ctx.mode === 'strip' ? [] : v;
+        const mutate = shouldMutate(ctx);
+        const data = mutate ? v : [];
         for (let i = 0; i < v.length; i++) {
             const val = childValidator(v[i], path + '[' + i + ']', ctx);
-            if (ctx.mode === 'strip') {
-                data.push(val);
-            }
+            data[i] = val;
         }
         return data;
     },
@@ -154,20 +549,67 @@ export const validators = {
         for (const [key, isOptional, validator] of props) {
             const val = v[key];
             const oldErrors = ctx.errors.length;
+            const wasSuccess = ctx.success;
             const result = validator(val, path + '.' + key, ctx);
             if (ctx.success) {
                 data[key] = result;
             }
             else if (isOptional && val === undefined) {
-                ctx.success = true;
                 ctx.errors.length = oldErrors;
+                ctx.success = wasSuccess;
+            }
+        }
+    },
+    objectShell: (v, ctx) => {
+        if (shouldMutate(ctx)) {
+            return v;
+        }
+        if (!isPlainObject(v)) {
+            return v;
+        }
+        if (ctx.mode === 'strip') {
+            return {};
+        }
+        return { ...v };
+    },
+    stripExtras: (data, ctx, allowedKeys) => {
+        if (!shouldMutate(ctx) || ctx.mode !== 'strip' || !allowedKeys || !data || typeof data !== 'object') {
+            return data;
+        }
+        for (const k of Object.keys(data)) {
+            if (!allowedKeys.includes(k)) {
+                delete data[k];
+            }
+        }
+        return data;
+    },
+    additionalProps: (v, data, path, ctx, knownKeys, childValidator) => {
+        if (!isPlainObject(v)) {
+            return;
+        }
+        for (const key of Object.keys(v)) {
+            if (knownKeys.includes(key)) {
+                continue;
             }
+            data[key] = childValidator(v[key], path + '.' + key, ctx);
         }
     },
     object: (v, path, ctx, allowedKeys, expected = 'Type<Object>') => {
-        if (!v || typeof v !== 'object' || Array.isArray(v)) {
-            report(ctx, path, expected, v);
-            return false;
+        if (!isPlainObject(v)) {
+            if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'Object');
+                if (isPlainObject(converted)) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, expected, v);
+                    return false;
+                }
+            }
+            else {
+                report(ctx, path, expected, v);
+                return false;
+            }
         }
         if (ctx.mode === 'strict' && allowedKeys) {
             for (const k of Object.keys(v)) {
@@ -176,10 +618,10 @@ export const validators = {
                 }
             }
         }
-        return true;
+        return v;
     },
     templateLiteral: (v, path, ctx, regex, expected) => {
-        if (typeof v !== 'string' || !regex.test(v)) {
+        if (typeof v !== 'string' || !testRegex(regex, v)) {
             report(ctx, path, expected, v);
         }
         return v;
@@ -226,15 +668,13 @@ export const validators = {
                 report(ctx, path, `MultipleOf<${n}>`, v, message);
             }
         }
-        else {
-            if (v % n !== 0) {
-                report(ctx, path, `MultipleOf<${n}>`, v, message);
-            }
+        else if (!isMultipleOfNumber(v, n)) {
+            report(ctx, path, `MultipleOf<${n}>`, v, message);
         }
         return v;
     },
     pattern: (v, path, ctx, regex, expected, message) => {
-        if (!regex.test(v)) {
+        if (!testRegex(regex, v)) {
             report(ctx, path, expected, v, message);
         }
         return v;
@@ -242,9 +682,13 @@ export const validators = {
     format: (v, path, ctx, format, message) => {
         let regex;
         let isValid = true;
+        let result = v;
         switch (format) {
             case 'email':
-                regex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+                isValid = isEmail(v);
+                break;
+            case 'idn-email':
+                isValid = isIdnEmail(v);
                 break;
             case 'uuid':
                 regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -259,11 +703,27 @@ export const validators = {
                 regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
                 break;
             case 'date':
-                regex = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
-                break;
+                {
+                    const parsed = parseFormatDate(v);
+                    if (!parsed) {
+                        isValid = false;
+                    }
+                    else if (wantsQuery(ctx)) {
+                        result = parsed;
+                    }
+                    break;
+                }
             case 'date-time':
-                regex = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])[tT ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[zZ]|[+-]\d{2}:\d{2})$/;
-                break;
+                {
+                    const parsed = parseFormatDateTime(v);
+                    if (!parsed) {
+                        isValid = false;
+                    }
+                    else if (wantsQuery(ctx)) {
+                        result = parsed;
+                    }
+                    break;
+                }
             case 'byte':
                 regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
                 break;
@@ -278,10 +738,25 @@ export const validators = {
                 ;
                 break;
             case 'hostname':
-                regex = /^(?=.{1,253}$)(?:(?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,63}$/;
+                isValid = isHostname(v);
+                break;
+            case 'idn-hostname':
+                isValid = isIdnHostname(v);
                 break;
             case 'uri':
-                regex = /^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/;
+                isValid = isUri(v);
+                break;
+            case 'uri-reference':
+                isValid = isUriReference(v);
+                break;
+            case 'iri':
+                isValid = isIri(v);
+                break;
+            case 'iri-reference':
+                isValid = isIriReference(v);
+                break;
+            case 'uri-template':
+                isValid = isUriTemplate(v);
                 break;
             case 'time':
                 regex = /^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[zZ]|[+-]\d{2}:\d{2})$/;
@@ -292,15 +767,17 @@ export const validators = {
             case 'objectId':
                 regex = /^[0-9a-fA-F]{24}$/;
                 break;
-            default: break;
+            default:
+                isValid = false;
+                break;
         }
-        if (regex && !regex.test(v)) {
+        if (regex && !testRegex(regex, v)) {
             isValid = false;
         }
         if (!isValid) {
             report(ctx, path, `Format<${format}>`, v, message);
         }
-        return v;
+        return result;
     },
     minItems: (v, path, ctx, min, message) => {
         if (v.length < min) {
@@ -318,7 +795,9 @@ export const validators = {
         const seen = new Set();
         for (let i = 0; i < v.length; i++) {
             const item = v[i];
-            const key = typeof item === 'object' && item !== null ? JSON.stringify(item) : item;
+            const key = typeof item === 'object' && item !== null
+                ? stableStringify(item) ?? item
+                : item;
             if (seen.has(key)) {
                 report(ctx, path, 'UniqueItems', v, message);
                 break;
@@ -328,58 +807,107 @@ export const validators = {
         return v;
     },
     custom: (v, path, ctx, fn, message) => {
-        const parentPath = path.includes('.') ? path.substring(0, path.lastIndexOf('.')) : '';
+        const pathParts = tokenizePath(path);
+        const parentPath = joinPathSegments(pathParts.slice(0, -1));
         const parent = getValueAtPath(ctx.root, parentPath);
-        const indexMatch = path.match(/\[(\d+)\]$/);
-        const index = indexMatch ? parseInt(indexMatch[1], 10) : undefined;
-        if (!fn(v, { parent, root: ctx.root, path, index })) {
+        const last = pathParts[pathParts.length - 1];
+        const index = last && last.startsWith('[') ? parseInt(last.slice(1, -1), 10) : undefined;
+        if (!fn(v, { parent, root: ctx.root, path, index: Number.isNaN(index) ? undefined : index })) {
             report(ctx, path, fn.name ? `Custom<${fn.name}>` : 'Custom', v, message);
         }
         return v;
     },
     union: (v, path, ctx, checks, expected = 'Type<Union>') => {
+        const unionErrors = [];
         // Pass 1: No conversion
         for (const check of checks) {
-            const subCtx = { ...ctx, success: true, errors: [], tryConvert: false };
+            const subCtx = { ...ctx, success: true, errors: [], from: undefined };
             const val = check(v, path, subCtx);
             if (subCtx.success) {
                 return val;
             }
+            unionErrors.push(...subCtx.errors);
         }
-        // Pass 2: With conversion
-        const unionErrors = [];
-        for (const check of checks) {
-            const subCtx = { ...ctx, success: true, errors: [], tryConvert: true };
-            const val = check(v, path, subCtx);
-            if (subCtx.success) {
-                return val;
+        // Pass 2: With conversion (only when caller opted in)
+        if (ctx.from) {
+            unionErrors.length = 0;
+            for (const check of checks) {
+                const subCtx = { ...ctx, success: true, errors: [] };
+                const val = check(v, path, subCtx);
+                if (subCtx.success) {
+                    return val;
+                }
+                unionErrors.push(...subCtx.errors);
             }
-            unionErrors.push(...subCtx.errors);
         }
         ctx.success = false;
         ctx.errors.push({
             path,
             value: v,
-            error: expected
+            error: expected,
+            issues: unionErrors.length > 0 ? unionErrors : undefined
         });
-        ctx.errors.push(...unionErrors);
         return v;
     },
     tuple: (v, path, ctx, checks) => {
         if (!Array.isArray(v) || v.length !== checks.length) {
-            report(ctx, path, `Tuple<${checks.length}>`, v);
-            return v;
+            if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'tuple');
+                if (Array.isArray(converted) && converted.length === checks.length) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, `Tuple<${checks.length}>`, v);
+                    return v;
+                }
+            }
+            else {
+                report(ctx, path, `Tuple<${checks.length}>`, v);
+                return v;
+            }
         }
-        const data = ctx.mode === 'strip' ? [] : v;
+        const mutate = shouldMutate(ctx);
+        const data = mutate ? v : [];
         for (let i = 0; i < checks.length; i++) {
-            const val = checks[i](v[i], path + '[' + i + ']', ctx);
-            if (ctx.mode === 'strip') {
-                data.push(val);
-            }
+            data[i] = checks[i](v[i], path + '[' + i + ']', ctx);
         }
         return data;
     },
     any: (v) => v,
+    never: (v, path, ctx) => {
+        if (typeof ctx.from === 'function') {
+            fromCustom(ctx, path, v, 'never');
+        }
+        report(ctx, path, 'Type<never>', v);
+        return v;
+    },
+    symbol: (v, path, ctx) => {
+        if (typeof v === 'symbol') {
+            return v;
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'symbol');
+            if (typeof converted === 'symbol') {
+                return converted;
+            }
+        }
+        report(ctx, path, 'Type<symbol>', v);
+        return v;
+    },
+    instanceOf: (v, path, ctx, typeName) => {
+        const ctor = globalThis[typeName];
+        if (ctor && v instanceof ctor) {
+            return v;
+        }
+        if (typeof ctx.from === 'function') {
+            const converted = fromCustom(ctx, path, v, 'instance');
+            if (ctor && converted instanceof ctor) {
+                return converted;
+            }
+        }
+        report(ctx, path, `Type<${typeName}>`, v);
+        return v;
+    },
     requires: (v, path, ctx, reqs, message) => {
         if (v === undefined || v === null) {
             return v;
@@ -393,64 +921,151 @@ export const validators = {
         return v;
     },
     record: (v, path, ctx, childValidator) => {
-        if (!v || typeof v !== 'object' || Array.isArray(v)) {
-            report(ctx, path, 'Type<Object>', v);
-            return v;
+        if (!isPlainObject(v)) {
+            if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'Object');
+                if (isPlainObject(converted)) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, 'Type<Object>', v);
+                    return v;
+                }
+            }
+            else {
+                report(ctx, path, 'Type<Object>', v);
+                return v;
+            }
         }
-        const data = ctx.mode === 'strip' ? {} : v;
+        const mutate = shouldMutate(ctx);
+        const data = mutate ? v : {};
         for (const key of Object.keys(v)) {
-            const val = childValidator(v[key], path + '.' + key, ctx);
-            if (ctx.mode === 'strip') {
-                data[key] = val;
-            }
+            data[key] = childValidator(v[key], path + '.' + key, ctx);
         }
         return data;
     },
     set: (v, path, ctx, childValidator, message) => {
         if (!(v instanceof Set)) {
-            if (ctx.tryConvert && Array.isArray(v)) {
+            if (wantsJsonRevive(ctx) && Array.isArray(v)) {
                 v = new Set(v);
             }
-            else if (ctx.tryConvert && v !== undefined && v !== null) {
+            else if (wantsQuery(ctx) && v !== undefined && v !== null) {
                 v = new Set([v]);
             }
+            else if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'Set');
+                if (converted instanceof Set) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, 'Type<Set>', v, message);
+                    return v;
+                }
+            }
             else {
                 report(ctx, path, 'Type<Set>', v, message);
                 return v;
             }
         }
-        const data = ctx.mode === 'strip' ? new Set() : v;
+        const mutate = shouldMutate(ctx);
+        const source = [...v];
+        if (mutate) {
+            v.clear();
+        }
+        const data = mutate ? v : new Set();
         let index = 0;
-        for (const item of v) {
-            const val = childValidator(item, `${path}[${index}]`, ctx);
-            if (ctx.mode === 'strip') {
-                data.add(val);
-            }
+        for (const item of source) {
+            data.add(childValidator(item, `${path}[${index}]`, ctx));
             index++;
         }
         return data;
     },
     map: (v, path, ctx, keyValidator, valueValidator, message) => {
         if (!(v instanceof Map)) {
-            if (ctx.tryConvert && typeof v === 'object' && v !== null && !Array.isArray(v)) {
+            if (wantsJsonRevive(ctx) && isPlainObject(v)) {
                 v = new Map(Object.entries(v));
             }
+            else if (typeof ctx.from === 'function') {
+                const converted = fromCustom(ctx, path, v, 'Map');
+                if (converted instanceof Map) {
+                    v = converted;
+                }
+                else {
+                    report(ctx, path, 'Type<Map>', v, message);
+                    return v;
+                }
+            }
             else {
                 report(ctx, path, 'Type<Map>', v, message);
                 return v;
             }
         }
-        const data = ctx.mode === 'strip' ? new Map() : v;
-        for (const [key, val] of v.entries()) {
+        const mutate = shouldMutate(ctx);
+        const source = [...v.entries()];
+        if (mutate) {
+            v.clear();
+        }
+        const data = mutate ? v : new Map();
+        for (const [key, val] of source) {
             const validatedKey = keyValidator(key, `${path}.key(${JSON.stringify(key)})`, ctx);
             const validatedVal = valueValidator(val, `${path}[${JSON.stringify(key)}]`, ctx);
-            if (ctx.mode === 'strip') {
-                data.set(validatedKey, validatedVal);
-            }
+            data.set(validatedKey, validatedVal);
         }
         return data;
     }
 };
+function tokenizePath(path) {
+    const cleanPath = path.startsWith('.') ? path.substring(1) : path;
+    if (!cleanPath) {
+        return [];
+    }
+    const segments = [];
+    let buf = '';
+    for (let i = 0; i < cleanPath.length; i++) {
+        const ch = cleanPath[i];
+        if (ch === '.') {
+            if (buf) {
+                segments.push(buf);
+                buf = '';
+            }
+        }
+        else if (ch === '[') {
+            if (buf) {
+                segments.push(buf);
+                buf = '';
+            }
+            const end = cleanPath.indexOf(']', i);
+            if (end === -1) {
+                buf += cleanPath.substring(i);
+                break;
+            }
+            segments.push(cleanPath.substring(i, end + 1));
+            i = end;
+        }
+        else {
+            buf += ch;
+        }
+    }
+    if (buf) {
+        segments.push(buf);
+    }
+    return segments;
+}
+function joinPathSegments(segments) {
+    let result = '';
+    for (const seg of segments) {
+        if (seg.startsWith('[')) {
+            result += seg;
+        }
+        else if (result) {
+            result += '.' + seg;
+        }
+        else {
+            result = seg;
+        }
+    }
+    return result;
+}
 function resolvePath(currentPath, targetPath) {
     if (!targetPath.startsWith('.')) {
         return targetPath;
@@ -458,39 +1073,33 @@ function resolvePath(currentPath, targetPath) {
     const dotsMatch = targetPath.match(/^\.+/);
     const dots = dotsMatch ? dotsMatch[0].length : 0;
     const targetClean = targetPath.substring(dots);
-    const cleanCurrentPath = currentPath.startsWith('.') ? currentPath.substring(1) : currentPath;
-    const currentParts = cleanCurrentPath ? cleanCurrentPath.split('.') : [];
-    const baseParts = currentParts.slice(0, currentParts.length - dots);
+    const currentParts = tokenizePath(currentPath);
+    const baseParts = currentParts.slice(0, Math.max(0, currentParts.length - dots));
     if (targetClean) {
-        baseParts.push(targetClean);
+        baseParts.push(...tokenizePath(targetClean));
     }
-    return baseParts.join('.');
+    return joinPathSegments(baseParts);
 }
 function getValueAtPath(obj, path) {
     if (!obj || typeof obj !== 'object') {
         return undefined;
     }
-    const cleanPath = path.startsWith('.') ? path.substring(1) : path;
-    if (!cleanPath) {
+    const parts = tokenizePath(path);
+    if (parts.length === 0) {
         return obj;
     }
-    const parts = cleanPath.split('.');
     let current = obj;
     for (const part of parts) {
         if (current === null || current === undefined || typeof current !== 'object') {
             return undefined;
         }
-        const matches = part.split('[');
-        const baseKey = matches[0];
-        current = current[baseKey];
-        for (let i = 1; i < matches.length; i++) {
-            if (current === null || current === undefined || typeof current !== 'object') {
-                return undefined;
-            }
-            const idxStr = matches[i].replace(']', '');
-            const idx = parseInt(idxStr, 10);
+        if (part.startsWith('[') && part.endsWith(']')) {
+            const idx = parseInt(part.slice(1, -1), 10);
             current = current[idx];
         }
+        else {
+            current = current[part];
+        }
     }
     return current;
 }
@@ -536,18 +1145,20 @@ export class MetadataStoreClass {
     is(validator, value, options) {
         const opt = options;
         const mode = typeof opt === 'string' ? opt : (opt?.mode || 'strict');
-        const tryConvert = typeof opt === 'object' ? opt?.tryConvert : undefined;
+        // Type predicates require the value already match T — never coerce.
         const wrapArrays = typeof opt === 'object' ? opt?.wrapArrays : undefined;
-        const ctx = { success: true, errors: [], mode, tryConvert, wrapArrays, root: value };
+        const mutate = typeof opt === 'object' ? opt?.mutate === true : false;
+        const ctx = { success: true, errors: [], mode, wrapArrays, mutate, root: value };
         validator(value, '', ctx);
         return ctx.success;
     }
     assert(validator, value, options) {
         const opt = options;
         const mode = typeof opt === 'string' ? opt : (opt?.mode || 'strict');
-        const tryConvert = typeof opt === 'object' ? opt?.tryConvert : undefined;
+        const from = typeof opt === 'object' ? opt?.from : undefined;
         const wrapArrays = typeof opt === 'object' ? opt?.wrapArrays : undefined;
-        const ctx = { success: true, errors: [], mode, tryConvert, wrapArrays, root: value };
+        const mutate = typeof opt === 'object' ? opt?.mutate === true : false;
+        const ctx = { success: true, errors: [], mode, from, wrapArrays, mutate, root: value };
         const res = validator(value, '', ctx);
         if (!ctx.success) {
             if (typeof opt === 'object' && opt?.errorFactory) {
@@ -557,26 +1168,48 @@ export class MetadataStoreClass {
         }
         return res;
     }
+    assertGuard(validator, value, options) {
+        const opt = options;
+        const mode = typeof opt === 'string' ? opt : (opt?.mode || 'strict');
+        // Assertion predicates require the value already match T — never coerce.
+        const wrapArrays = typeof opt === 'object' ? opt?.wrapArrays : undefined;
+        const mutate = typeof opt === 'object' ? opt?.mutate === true : false;
+        const ctx = { success: true, errors: [], mode, wrapArrays, mutate, root: value };
+        validator(value, '', ctx);
+        if (!ctx.success) {
+            if (typeof opt === 'object' && opt?.errorFactory) {
+                throw opt.errorFactory(ctx.errors);
+            }
+            throw new Error('Validation Error: ' + ctx.errors.map(e => e.path ? `${e.path}: ${e.error}` : e.error).join(', '));
+        }
+    }
     validate(validator, value, options) {
         const opt = options;
         const mode = typeof opt === 'string' ? opt : (opt?.mode || 'strict');
-        const tryConvert = typeof opt === 'object' ? opt?.tryConvert : undefined;
+        const from = typeof opt === 'object' ? opt?.from : undefined;
         const wrapArrays = typeof opt === 'object' ? opt?.wrapArrays : undefined;
-        const ctx = { success: true, errors: [], mode, tryConvert, wrapArrays, root: value };
+        const mutate = typeof opt === 'object' ? opt?.mutate === true : false;
+        const ctx = { success: true, errors: [], mode, from, wrapArrays, mutate, root: value };
         const res = validator(value, '', ctx);
         return { success: ctx.success, errors: ctx.errors, data: res };
     }
 }
 export function groupErrorsByPath(errors) {
     const grouped = {};
-    for (const err of errors) {
-        if (!grouped[err.path]) {
-            grouped[err.path] = { value: err.value, errors: [] };
-        }
-        if (!grouped[err.path].errors.includes(err.error)) {
-            grouped[err.path].errors.push(err.error);
+    const visit = (list) => {
+        for (const err of list) {
+            if (!grouped[err.path]) {
+                grouped[err.path] = { value: err.value, errors: [] };
+            }
+            if (!grouped[err.path].errors.includes(err.error)) {
+                grouped[err.path].errors.push(err.error);
+            }
+            if (err.issues?.length) {
+                visit(err.issues);
+            }
         }
-    }
+    };
+    visit(errors);
     return grouped;
 }
 export const MetadataStore = new MetadataStoreClass();
@@ -608,6 +1241,67 @@ export function compileSchema(schema) {
             compiledDefs.set(refPath, proxy);
             return proxy;
         }
+        if (subSchema['x-typescript-type'] === 'Date') {
+            return (v, path, ctx) => validators.date(v, path, ctx);
+        }
+        if (subSchema['x-typescript-type'] === 'RegExp') {
+            return (v, path, ctx) => validators.regexp(v, path, ctx);
+        }
+        if (subSchema['x-typescript-type'] === 'bigint') {
+            return (v, path, ctx) => validators.bigint(v, path, ctx);
+        }
+        if (subSchema['x-typescript-type'] === 'undefined') {
+            return (v, path, ctx) => validators.undefined(v, path, ctx);
+        }
+        if (subSchema['x-typescript-type'] === 'Set') {
+            const child = build(subSchema.items || {});
+            return (v, path, ctx) => validators.set(v, path, ctx, child);
+        }
+        if (subSchema['x-typescript-type'] === 'Map') {
+            const keyCheck = build(subSchema.key || { type: 'string' });
+            const valueCheck = build(subSchema.value || {});
+            return (v, path, ctx) => validators.map(v, path, ctx, keyCheck, valueCheck);
+        }
+        if (subSchema['x-typescript-type'] === 'Promise') {
+            return (v, path, ctx) => {
+                if (!(v instanceof Promise)) {
+                    report(ctx, path, 'Type<Promise>', v);
+                }
+                return v;
+            };
+        }
+        if (typeof subSchema['x-typescript-type'] === 'string' &&
+            ['Uint8Array', 'Uint16Array', 'Uint32Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Float32Array', 'Float64Array', 'ArrayBuffer', 'SharedArrayBuffer', 'DataView', 'Buffer'].includes(subSchema['x-typescript-type'])) {
+            const typeName = subSchema['x-typescript-type'];
+            return (v, path, ctx) => {
+                const ctor = globalThis[typeName];
+                if (!ctor || !(v instanceof ctor)) {
+                    report(ctx, path, `Type<${typeName}>`, v);
+                }
+                return v;
+            };
+        }
+        if (subSchema.allOf) {
+            const checks = subSchema.allOf.map((s) => build(s));
+            return (v, path, ctx) => {
+                const prevMode = ctx.mode;
+                if (ctx.mode !== 'strip') {
+                    ctx.mode = 'relaxed';
+                }
+                let data = validators.objectShell(v, ctx);
+                for (const check of checks) {
+                    const val = check(v, path, ctx);
+                    if (isPlainObject(val) && isPlainObject(data)) {
+                        Object.assign(data, val);
+                    }
+                    else {
+                        data = val;
+                    }
+                }
+                ctx.mode = prevMode;
+                return data;
+            };
+        }
         if (subSchema.type === 'string') {
             const minLength = subSchema.minLength;
             const maxLength = subSchema.maxLength;
@@ -629,7 +1323,7 @@ export function compileSchema(schema) {
                     validators.pattern(v, path, ctx, pattern, patternStr);
                 }
                 if (format !== undefined) {
-                    validators.format(v, path, ctx, format);
+                    v = validators.format(v, path, ctx, format);
                 }
                 return v;
             };
@@ -638,6 +1332,8 @@ export function compileSchema(schema) {
             const isInt = subSchema.type === 'integer';
             const minimum = subSchema.minimum;
             const maximum = subSchema.maximum;
+            const exclusiveMinimum = subSchema.exclusiveMinimum;
+            const exclusiveMaximum = subSchema.exclusiveMaximum;
             const multipleOf = subSchema.multipleOf;
             return (v, path, ctx) => {
                 v = validators.number(v, path, ctx);
@@ -653,6 +1349,12 @@ export function compileSchema(schema) {
                 if (maximum !== undefined) {
                     validators.maximum(v, path, ctx, maximum);
                 }
+                if (exclusiveMinimum !== undefined) {
+                    validators.exclusiveMinimum(v, path, ctx, exclusiveMinimum);
+                }
+                if (exclusiveMaximum !== undefined) {
+                    validators.exclusiveMaximum(v, path, ctx, exclusiveMaximum);
+                }
                 if (multipleOf !== undefined) {
                     validators.multipleOf(v, path, ctx, multipleOf);
                 }
@@ -704,31 +1406,25 @@ export function compileSchema(schema) {
                 const check = build(s);
                 return [key, isOptional, check];
             });
-            const allowedKeys = Object.keys(subSchema.properties || {});
+            const knownKeys = Object.keys(subSchema.properties || {});
+            const additional = 'additionalProperties' in subSchema
+                ? subSchema.additionalProperties
+                : false;
+            const strictKeys = additional === false ? knownKeys : undefined;
+            const additionalCheck = additional && typeof additional === 'object' ? build(additional) : undefined;
             return (v, path, ctx) => {
-                if (!validators.object(v, path, ctx, allowedKeys, 'Object')) {
+                const obj = validators.object(v, path, ctx, strictKeys, 'Object');
+                if (obj === false) {
                     return v;
                 }
-                let data = v;
-                if (ctx.mode === 'strip') {
-                    let hasAdditional = false;
-                    const keys = Object.keys(v);
-                    if (keys.length > allowedKeys.length) {
-                        hasAdditional = true;
-                    }
-                    else {
-                        for (let i = 0; i < keys.length; i++) {
-                            if (!allowedKeys.includes(keys[i])) {
-                                hasAdditional = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (hasAdditional) {
-                        data = {};
-                    }
+                const data = validators.objectShell(obj, ctx);
+                validators.props(obj, data, path, ctx, propVals);
+                if (additionalCheck) {
+                    validators.additionalProps(obj, data, path, ctx, knownKeys, additionalCheck);
+                }
+                else if (additional === false) {
+                    validators.stripExtras(data, ctx, knownKeys);
                 }
-                validators.props(v, data, path, ctx, propVals);
                 return data;
             };
         }
@@ -746,24 +1442,31 @@ export function compileSchema(schema) {
     return build(schema);
 }
 export function toZodIssues(errors) {
-    return errors.map((err) => {
-        const zodPath = err.path
-            .split(/\.|\[|\]/)
-            .filter(Boolean)
-            .map((segment) => {
-            if (isNaN(Number(segment))) {
-                return segment;
-            }
-            return Number(segment);
-        });
-        const issue = {
-            code: 'custom',
-            path: zodPath,
-            message: err.error,
-            received: err.value
-        };
-        return issue;
-    });
+    const issues = [];
+    const visit = (list) => {
+        for (const err of list) {
+            const zodPath = err.path
+                .split(/\.|\[|\]/)
+                .filter(Boolean)
+                .map((segment) => {
+                if (isNaN(Number(segment))) {
+                    return segment;
+                }
+                return Number(segment);
+            });
+            issues.push({
+                code: 'custom',
+                path: zodPath,
+                message: err.error,
+                received: err.value
+            });
+            if (err.issues?.length) {
+                visit(err.issues);
+            }
+        }
+    };
+    visit(errors);
+    return issues;
 }
 export class ZodLikeError extends Error {
     issues;