vellum-ai 0.0.45 → 0.1.0

package/dist/core/schemas/builders/record/record.js

@@ -1,91 +1,106 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.record = void 0;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function record(keySchema, valueSchema) {
     const baseSchema = {
-        parse: async (raw, opts) => {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
             return validateAndTransformRecord({
                 value: raw,
-                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
-                transformKey: (key) => keySchema.parse(key, opts),
-                transformValue: (value) => valueSchema.parse(value, opts),
+                isKeyNumeric: (yield keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.parse(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
             return validateAndTransformRecord({
                 value: parsed,
-                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
-                transformKey: (key) => keySchema.json(key, opts),
-                transformValue: (value) => valueSchema.json(value, opts),
+                isKeyNumeric: (yield keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.json(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
+        }),
         getType: () => Schema_1.SchemaType.RECORD,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.record = record;
-async function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, }) {
-    if (!(0, isPlainObject_1.isPlainObject)(value)) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: [],
-                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
-                },
-            ],
-        };
-    }
-    return (0, entries_1.entries)(value).reduce(async (accPromise, [stringKey, value]) => {
-        // skip nullish keys
-        if (value == null) {
-            return accPromise;
+function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, isPlainObject_1.isPlainObject)(value)) {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
+                    },
+                ],
+            };
         }
-        const acc = await accPromise;
-        let key = stringKey;
-        if (isKeyNumeric) {
-            const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
-            if (!isNaN(numberKey)) {
-                key = numberKey;
+        return (0, entries_1.entries)(value).reduce((accPromise, [stringKey, value]) => __awaiter(this, void 0, void 0, function* () {
+            // skip nullish keys
+            if (value == null) {
+                return accPromise;
+            }
+            const acc = yield accPromise;
+            let key = stringKey;
+            if (isKeyNumeric) {
+                const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+                if (!isNaN(numberKey)) {
+                    key = numberKey;
+                }
+            }
+            const transformedKey = yield transformKey(key);
+            const transformedValue = yield transformValue(value, key);
+            if (acc.ok && transformedKey.ok && transformedValue.ok) {
+                return {
+                    ok: true,
+                    value: Object.assign(Object.assign({}, acc.value), { [transformedKey.value]: transformedValue.value }),
+                };
+            }
+            const errors = [];
+            if (!acc.ok) {
+                errors.push(...acc.errors);
+            }
+            if (!transformedKey.ok) {
+                errors.push(...transformedKey.errors);
+            }
+            if (!transformedValue.ok) {
+                errors.push(...transformedValue.errors);
             }
-        }
-        const transformedKey = await transformKey(key);
-        const transformedValue = await transformValue(value);
-        if (acc.ok && transformedKey.ok && transformedValue.ok) {
             return {
-                ok: true,
-                value: {
-                    ...acc.value,
-                    [transformedKey.value]: transformedValue.value,
-                },
+                ok: false,
+                errors,
             };
-        }
-        const errors = [];
-        if (!acc.ok) {
-            errors.push(...acc.errors);
-        }
-        if (!transformedKey.ok) {
-            errors.push(...transformedKey.errors.map((error) => ({
-                path: [`${key} (key)`, ...error.path],
-                message: error.message,
-            })));
-        }
-        if (!transformedValue.ok) {
-            errors.push(...transformedValue.errors.map((error) => ({
-                path: [stringKey, ...error.path],
-                message: error.message,
-            })));
-        }
-        return {
-            ok: false,
-            errors,
-        };
-    }, Promise.resolve({ ok: true, value: {} }));
+        }), Promise.resolve({ ok: true, value: {} }));
+    });
 }

package/dist/core/schemas/builders/schema-utils/JsonError.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonError = void 0;
 const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
 class JsonError extends Error {
-    errors;
     constructor(errors) {
         super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
         this.errors = errors;

package/dist/core/schemas/builders/schema-utils/ParseError.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseError = void 0;
 const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
 class ParseError extends Error {
-    errors;
     constructor(errors) {
         super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
         this.errors = errors;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transform = exports.optional = exports.getSchemaUtils = void 0;
 const Schema_1 = require("../../Schema");
@@ -8,20 +17,20 @@ function getSchemaUtils(schema) {
     return {
         optional: () => optional(schema),
         transform: (transformer) => transform(schema, transformer),
-        parseOrThrow: async (raw, opts) => {
-            const parsed = await schema.parse(raw, opts);
+        parseOrThrow: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
             if (parsed.ok) {
                 return parsed.value;
             }
             throw new ParseError_1.ParseError(parsed.errors);
-        },
-        jsonOrThrow: async (parsed, opts) => {
-            const raw = await schema.json(parsed, opts);
+        }),
+        jsonOrThrow: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const raw = yield schema.json(parsed, opts);
             if (raw.ok) {
                 return raw.value;
             }
             throw new JsonError_1.JsonError(raw.errors);
-        },
+        }),
     };
 }
 exports.getSchemaUtils = getSchemaUtils;
@@ -50,16 +59,13 @@ function optional(schema) {
         },
         getType: () => Schema_1.SchemaType.OPTIONAL,
     };
-    return {
-        ...baseSchema,
-        ...getSchemaUtils(baseSchema),
-    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
 exports.optional = optional;
 function transform(schema, transformer) {
     const baseSchema = {
-        parse: async (raw, opts) => {
-            const parsed = await schema.parse(raw, opts);
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
             if (!parsed.ok) {
                 return parsed;
             }
@@ -67,16 +73,13 @@ function transform(schema, transformer) {
                 ok: true,
                 value: transformer.transform(parsed.value),
             };
-        },
-        json: async (transformed, opts) => {
-            const parsed = await transformer.untransform(transformed);
+        }),
+        json: (transformed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield transformer.untransform(transformed);
             return schema.json(parsed, opts);
-        },
+        }),
         getType: () => schema.getType(),
     };
-    return {
-        ...baseSchema,
-        ...getSchemaUtils(baseSchema),
-    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
 exports.transform = transform;

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -1,3 +1,4 @@
-export { getSchemaUtils, optional, transform, type SchemaUtils } from "./getSchemaUtils";
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
+export type { SchemaUtils } from "./getSchemaUtils";
 export { JsonError } from "./JsonError";
 export { ParseError } from "./ParseError";

package/dist/core/schemas/builders/set/set.js

@@ -1,14 +1,25 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.set = void 0;
 const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const list_1 = require("../list");
 const schema_utils_1 = require("../schema-utils");
 function set(schema) {
     const listSchema = (0, list_1.list)(schema);
     const baseSchema = {
-        parse: async (raw, opts) => {
-            const parsedList = await listSchema.parse(raw, opts);
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsedList = yield listSchema.parse(raw, opts);
             if (parsedList.ok) {
                 return {
                     ok: true,
@@ -18,27 +29,25 @@ function set(schema) {
             else {
                 return parsedList;
             }
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!(parsed instanceof Set)) {
                 return {
                     ok: false,
                     errors: [
                         {
-                            path: [],
-                            message: "Not a Set",
+                            path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "Set"),
                         },
                     ],
                 };
             }
-            const jsonList = await listSchema.json([...parsed], opts);
+            const jsonList = yield listSchema.json([...parsed], opts);
             return jsonList;
-        },
+        }),
         getType: () => Schema_1.SchemaType.SET,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.set = set;

package/dist/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -1,2 +1,2 @@
-export { type inferParsedUnidiscriminatedUnionSchema, type inferRawUnidiscriminatedUnionSchema, type UndiscriminatedUnionSchema, } from "./types";
+export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from "./types";
 export { undiscriminatedUnion } from "./undiscriminatedUnion";

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -1,37 +1,51 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.undiscriminatedUnion = void 0;
 const Schema_1 = require("../../Schema");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function undiscriminatedUnion(schemas) {
     const baseSchema = {
-        parse: async (raw, opts) => {
-            return validateAndTransformUndiscriminatedUnion((schema) => schema.parse(raw, opts), schemas);
-        },
-        json: async (parsed, opts) => {
-            return validateAndTransformUndiscriminatedUnion((schema) => schema.json(parsed, opts), schemas);
-        },
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.parse(raw, opts), schemas, opts);
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.json(parsed, opts), schemas, opts);
+        }),
         getType: () => Schema_1.SchemaType.UNDISCRIMINATED_UNION,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.undiscriminatedUnion = undiscriminatedUnion;
-async function validateAndTransformUndiscriminatedUnion(transform, schemas) {
-    const errors = [];
-    for (const schema of schemas) {
-        const transformed = await transform(schema);
-        if (transformed.ok) {
-            return transformed;
-        }
-        else if (errors.length === 0) {
-            errors.push(...transformed.errors);
+function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const errors = [];
+        for (const [index, schema] of schemas.entries()) {
+            const transformed = yield transform(schema, Object.assign(Object.assign({}, opts), { skipValidation: false }));
+            if (transformed.ok) {
+                return transformed;
+            }
+            else {
+                for (const error of transformed.errors) {
+                    errors.push({
+                        path: error.path,
+                        message: `[Variant ${index}] ${error.message}`,
+                    });
+                }
+            }
         }
-    }
-    return {
-        ok: false,
-        errors,
-    };
+        return {
+            ok: false,
+            errors,
+        };
+    });
 }

package/dist/core/schemas/builders/union/index.d.ts

@@ -1,3 +1,4 @@
-export { discriminant, type Discriminant } from "./discriminant";
-export { type inferParsedDiscriminant, type inferParsedUnion, type inferRawDiscriminant, type inferRawUnion, type UnionSubtypes, } from "./types";
+export { discriminant } from "./discriminant";
+export type { Discriminant } from "./discriminant";
+export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
 export { union } from "./union";

package/dist/core/schemas/builders/union/union.js

@@ -1,9 +1,31 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.union = void 0;
 const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const keys_1 = require("../../utils/keys");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const enum_1 = require("../enum");
 const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
@@ -14,107 +36,106 @@ function union(discriminant, union) {
         : discriminant.parsedDiscriminant;
     const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
     const baseSchema = {
-        parse: async (raw, opts) => {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
             return transformAndValidateUnion({
                 value: raw,
                 discriminant: rawDiscriminant,
                 transformedDiscriminant: parsedDiscriminant,
-                transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.parse(discriminantValue, {
-                    allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
-                }),
+                transformDiscriminantValue: (discriminantValue) => {
+                    var _a;
+                    return discriminantValueSchema.parse(discriminantValue, {
+                        allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), rawDiscriminant],
+                    });
+                },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
-                allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+                allowUnrecognizedUnionMembers: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
                 transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts),
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
             return transformAndValidateUnion({
                 value: parsed,
                 discriminant: parsedDiscriminant,
                 transformedDiscriminant: rawDiscriminant,
-                transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.json(discriminantValue, {
-                    allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
-                }),
+                transformDiscriminantValue: (discriminantValue) => {
+                    var _a;
+                    return discriminantValueSchema.json(discriminantValue, {
+                        allowUnrecognizedEnumValues: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
+                        breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), parsedDiscriminant],
+                    });
+                },
                 getAdditionalPropertiesSchema: (discriminantValue) => union[discriminantValue],
-                allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+                allowUnrecognizedUnionMembers: opts === null || opts === void 0 ? void 0 : opts.allowUnrecognizedUnionMembers,
                 transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts),
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        },
+        }),
         getType: () => Schema_1.SchemaType.UNION,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-        ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema));
 }
 exports.union = union;
-async function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, }) {
-    if (!(0, isPlainObject_1.isPlainObject)(value)) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: [],
-                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
-                },
-            ],
-        };
-    }
-    const { [discriminant]: discriminantValue, ...additionalProperties } = value;
-    if (discriminantValue == null) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: [],
-                    message: `Missing discriminant ("${discriminant}")`,
-                },
-            ],
-        };
-    }
-    const transformedDiscriminantValue = await transformDiscriminantValue(discriminantValue);
-    if (!transformedDiscriminantValue.ok) {
-        return {
-            ok: false,
-            errors: transformedDiscriminantValue.errors.map((error) => ({
-                path: [discriminant, ...error.path],
-                message: error.message,
-            })),
-        };
-    }
-    const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
-    if (additionalPropertiesSchema == null) {
-        if (allowUnrecognizedUnionMembers) {
+function transformAndValidateUnion({ value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnrecognizedUnionMembers = false, transformAdditionalProperties, breadcrumbsPrefix = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, isPlainObject_1.isPlainObject)(value)) {
             return {
-                ok: true,
-                value: {
-                    [transformedDiscriminant]: transformedDiscriminantValue.value,
-                    ...additionalProperties,
-                },
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
+                    },
+                ],
             };
         }
-        else {
+        const _a = value, _b = discriminant, discriminantValue = _a[_b], additionalProperties = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        if (discriminantValue == null) {
             return {
                 ok: false,
                 errors: [
                     {
-                        path: [discriminant],
-                        message: "Unrecognized discriminant value",
+                        path: breadcrumbsPrefix,
+                        message: `Missing discriminant ("${discriminant}")`,
                     },
                 ],
             };
         }
-    }
-    const transformedAdditionalProperties = await transformAdditionalProperties(additionalProperties, additionalPropertiesSchema);
-    if (!transformedAdditionalProperties.ok) {
-        return transformedAdditionalProperties;
-    }
-    return {
-        ok: true,
-        value: {
-            [transformedDiscriminant]: discriminantValue,
-            ...transformedAdditionalProperties.value,
-        },
-    };
+        const transformedDiscriminantValue = yield transformDiscriminantValue(discriminantValue);
+        if (!transformedDiscriminantValue.ok) {
+            return {
+                ok: false,
+                errors: transformedDiscriminantValue.errors,
+            };
+        }
+        const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+        if (additionalPropertiesSchema == null) {
+            if (allowUnrecognizedUnionMembers) {
+                return {
+                    ok: true,
+                    value: Object.assign({ [transformedDiscriminant]: transformedDiscriminantValue.value }, additionalProperties),
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: [...breadcrumbsPrefix, discriminant],
+                            message: "Unexpected discriminant value",
+                        },
+                    ],
+                };
+            }
+        }
+        const transformedAdditionalProperties = yield transformAdditionalProperties(additionalProperties, additionalPropertiesSchema);
+        if (!transformedAdditionalProperties.ok) {
+            return transformedAdditionalProperties;
+        }
+        return {
+            ok: true,
+            value: Object.assign({ [transformedDiscriminant]: discriminantValue }, transformedAdditionalProperties.value),
+        };
+    });
 }

package/dist/core/schemas/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./builders";
-export { type inferParsed, type inferRaw, type Schema, type SchemaOptions } from "./Schema";
+export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";