@builder-builder/builder 0.0.13 → 0.0.15

package/dist/validate/model.js

@@ -1,223 +1,204 @@
 import { check } from '../check.js';
 import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
-import { builderError } from '../exception.js';
 import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
 import { resolver } from './resolve.js';
-import { builderErrorInvalidInput } from './result.js';
-export function builderErrorDuplicateName(name, location = []) {
-    return { ...builderError('duplicate-name', location), name };
-}
-export function builderErrorInvalidCollectionBounds(name, min, max, location = []) {
-    return { ...builderError('invalid-collection-bounds', location), name, min, max };
-}
-export function builderErrorInvalidPath(reason, location = []) {
-    return { ...builderError('invalid-path', location), reason };
-}
-export function builderErrorInvalidSelectMapKey(key, location = []) {
-    return { ...builderError('invalid-select-map-key', location), key };
-}
 const EMPTY_MODEL = validate(serialise.model(model()));
-export function validateModel(input, references = []) {
+export function validateModel(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        return [EMPTY_MODEL, [builderErrorInvalidInput('model')]];
+        errors.invalidInput('model');
+        return [EMPTY_MODEL, errors.errors];
     }
-    const resolve = resolver(references);
-    const [structure, structureErrors] = validateModelStructure(input, resolve, []);
+    const resolve = resolver(errors, references);
+    const structure = validateModelStructure(input, resolve, errors);
     const data = validate(modelsMerge(structure));
-    const expectationErrors = checkModelExpectations(data, structure, []);
-    return [data, [...expectationErrors, ...structureErrors]];
+    checkModelExpectations(data, structure, errors);
+    return [data, errors.errors];
 }
-export function checkModelExpectations(mergedModel, model, location) {
-    return [
-        ...checkExpectations(mergedModel, model.expectations, [...location, 'expectations']),
-        ...model.models.flatMap((nested, nestedIndex) => checkModelExpectations(mergedModel, nested, [
-            ...location,
-            'models',
-            nestedIndex
-        ]))
-    ];
+export function checkModelExpectations(mergedModel, rootModel, errors) {
+    recurse(rootModel);
+    function recurse(node) {
+        errors.scope('expectations', () => {
+            checkExpectations(mergedModel, node.expectations, errors);
+        });
+        errors.scope('models', () => {
+            node.models.forEach((nested, nestedIndex) => {
+                errors.scope(nestedIndex, () => {
+                    recurse(nested);
+                });
+            });
+        });
+    }
 }
-export function validateModelStructure(input, resolve, location) {
-    const [resolved, resolveErrors] = resolve(input, location);
+export function validateModelStructure(input, resolve, errors) {
+    const resolved = resolve(input);
     if (!check.is(BuilderModelSerialisedSchema, resolved)) {
-        return [validate(serialise.model(model())), resolveErrors];
+        return validate(serialise.model(model()));
     }
-    const errors = [...resolveErrors];
     const modelInput = resolved;
-    const childModels = modelInput.models.flatMap((part, partIndex) => {
-        const partLocation = [...location, 'models', partIndex];
-        const [child, childErrors] = validateModelStructure(part, resolve, partLocation);
-        errors.push(...childErrors);
-        return [child];
-    });
-    const [options, optionErrors] = walkEntries(modelInput.options, 'option', resolve, location);
-    const [components, componentErrors] = walkEntries(modelInput.components, 'component', resolve, location);
-    const [collections, collectionErrors] = walkEntries(modelInput.collections, 'collection', resolve, location);
-    errors.push(...optionErrors, ...componentErrors, ...collectionErrors);
     const skipPathValidation = modelInput.expectations.length > 0;
-    const checkPaths = (entry, entryLocation) => (skipPathValidation ? [] : checkEntryPaths(modelInput, entry, entryLocation));
-    options.forEach((entry, entryIndex) => errors.push(...checkPaths(entry, [...location, 'options', entryIndex])));
-    components.forEach((entry, entryIndex) => errors.push(...checkPaths(entry, [...location, 'components', entryIndex])));
-    const resolvedCollections = collections.map((entry, entryIndex) => {
-        const collectionLocation = [...location, 'collections', entryIndex];
-        errors.push(...checkPaths(entry, collectionLocation), ...checkCollectionBounds(entry, collectionLocation));
-        const [resolvedEntry, entryErrors] = resolveCollectionInnerModels(entry, resolve, [
-            ...collectionLocation,
-            'payload'
-        ]);
-        errors.push(...entryErrors);
-        return resolvedEntry;
-    });
-    const data = {
+    const childModels = errors.scope('models', () => modelInput.models.flatMap((part, partIndex) => errors.scope(partIndex, () => [validateModelStructure(part, resolve, errors)])));
+    const options = walkEntries(modelInput.options, 'option');
+    const components = walkEntries(modelInput.components, 'component');
+    const collections = walkCollections();
+    return {
         ...modelInput,
         models: childModels,
         options,
         components,
-        collections: resolvedCollections
+        collections
     };
-    return [data, errors];
-}
-function resolveCollectionInnerModels(entry, resolve, payloadLocation) {
-    const errors = [];
-    const newPayload = mapCollectionConfigs(entry.payload, payloadLocation, (config, configLocation) => {
-        if (!check.is(BuilderModelSerialisedSchema, config.model)) {
-            return config;
-        }
-        const [validated, modelErrors] = validateModelStructure(config.model, resolve, [...configLocation, 'model']);
-        errors.push(...modelErrors);
-        return { ...config, model: validated };
-    });
-    return [{ ...entry, payload: newPayload }, errors];
-}
-function mapCollectionConfigs(payload, location, visit) {
-    if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
-        return visit(payload, location);
+    function walkEntries(entries, entryKind) {
+        const seen = new Set();
+        const items = [];
+        errors.scope(`${entryKind}s`, () => {
+            entries.forEach((entry, entryIndex) => {
+                errors.scope(entryIndex, () => {
+                    const resolved = resolveEntry(entry, seen);
+                    if (resolved != null) {
+                        items.push(resolved);
+                    }
+                });
+            });
+        });
+        return items;
     }
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return payload;
-    }
-    const when = payload;
-    if (when.type === 'match') {
-        const selectMap = when.selectMap;
-        const newSelectMap = Object.fromEntries(Object.entries(selectMap).map(([key, value]) => [
-            key,
-            mapCollectionConfigs(value, [...location, 'selectMap', key], visit)
-        ]));
-        return { ...when, selectMap: newSelectMap };
+    function walkCollections() {
+        const seen = new Set();
+        const items = [];
+        errors.scope('collections', () => {
+            modelInput.collections.forEach((entry, entryIndex) => {
+                errors.scope(entryIndex, () => {
+                    const resolved = resolveEntry(entry, seen);
+                    if (resolved == null) {
+                        return;
+                    }
+                    checkCollectionBounds(resolved);
+                    items.push(resolved);
+                });
+            });
+        });
+        return items;
     }
-    return { ...when, payload: mapCollectionConfigs(when.payload, [...location, 'payload'], visit) };
-}
-function walkEntries(entries, entryKind, resolve, location) {
-    const seen = new Set();
-    const items = [];
-    const errors = [];
-    const arrayKey = `${entryKind}s`;
-    entries.forEach((entry, entryIndex) => {
-        const entryLocation = [...location, arrayKey, entryIndex];
+    function resolveEntry(entry, seen) {
         let paths = entry.paths;
         if (entry.paths != null) {
-            const [resolvedPaths, pathErrors] = resolve(entry.paths, [...entryLocation, 'paths']);
+            const resolvedPaths = errors.scope('paths', () => resolve(entry.paths));
             paths = resolvedPaths ?? entry.paths;
-            errors.push(...pathErrors);
         }
-        const [payload, payloadErrors] = resolve(entry.payload, [...entryLocation, 'payload']);
-        errors.push(...payloadErrors);
-        const resolved = { ...entry, paths, payload: payload ?? entry.payload };
-        if (seen.has(resolved.name)) {
-            errors.push(builderErrorDuplicateName(resolved.name, entryLocation));
+        const payload = errors.scope('payload', () => resolve(entry.payload));
+        const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
+        if (seen.has(resolvedEntry.name)) {
+            errors.duplicateName(resolvedEntry.name);
+            return null;
+        }
+        seen.add(resolvedEntry.name);
+        checkPaths(resolvedEntry);
+        return resolvedEntry;
+    }
+    function checkPaths(entry) {
+        if (skipPathValidation) {
             return;
         }
-        seen.add(resolved.name);
-        items.push(resolved);
-    });
-    return [items, errors];
-}
-function checkEntryPaths(modelInput, entry, location) {
-    const { name, paths, payload } = entry;
-    const directPaths = Array.isArray(paths)
-        ? paths.map((path, pathIndex) => [path, [...location, 'paths', pathIndex]])
-        : [];
-    const extractWhenPathsList = extractWhenPaths(payload, location);
-    return [...directPaths, ...extractWhenPathsList].flatMap(([path, pathLocation]) => {
-        const [reached, walkErrors] = walkPath([modelInput], path.slice(0, -1), name, path, pathLocation);
-        if (walkErrors.length > 0) {
-            return walkErrors;
+        const { paths, payload } = entry;
+        if (Array.isArray(paths)) {
+            errors.scope('paths', () => {
+                paths.forEach((path, pathIndex) => {
+                    errors.scope(pathIndex, () => {
+                        checkPath(path);
+                    });
+                });
+            });
+        }
+        checkWhenPaths(payload);
+    }
+    function checkPath(path) {
+        const reached = walkPath([modelInput], path.slice(0, -1));
+        if (reached == null) {
+            return;
         }
         const optionName = path.at(-1);
         if (!reached.some((candidate) => candidate.options.some((option) => option.name === optionName))) {
-            return [builderErrorInvalidPath('option-not-found', pathLocation)];
+            errors.invalidPath('option-not-found');
         }
-        return [];
-    });
-}
-function checkCollectionBounds(collection, location) {
-    return collectionConfigs(collection, location).flatMap(([{ min, max }]) => {
-        if (typeof min !== 'number' || typeof max !== 'number') {
-            return [];
+    }
+    function checkWhenPaths(payload) {
+        if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+            return;
         }
-        if (min < 0 || max <= 0 || max < min) {
-            return [builderErrorInvalidCollectionBounds(collection.name, min, max, location)];
+        if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
+            errors.scope('payload', () => {
+                errors.scope('matchPath', () => {
+                    checkPath(payload.matchPath);
+                });
+            });
+            return;
         }
-        return [];
-    });
+        if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
+            errors.scope('payload', () => {
+                errors.scope('unlessPath', () => {
+                    checkPath(payload.unlessPath);
+                });
+            });
+        }
+    }
+    function walkPath(candidates, remaining) {
+        if (remaining.length === 0) {
+            return candidates;
+        }
+        const [collectionName, index, ...rest] = remaining;
+        if (typeof collectionName !== 'string' || typeof index !== 'number') {
+            errors.invalidPath('shape');
+            return null;
+        }
+        const matchedConfigs = candidates.flatMap((current) => {
+            const collection = current.collections.find((entry) => entry.name === collectionName);
+            return collection == null ? [] : [collectionConfigs(collection)];
+        });
+        if (matchedConfigs.length === 0) {
+            errors.invalidPath('missing-collection');
+            return null;
+        }
+        const anyOutOfBounds = matchedConfigs.some((configs) => configs.length > 0 && configs.every(({ max }) => typeof max === 'number' && index >= max));
+        if (anyOutOfBounds) {
+            errors.invalidPath('out-of-bounds');
+            return null;
+        }
+        const next = matchedConfigs.flatMap((configs) => configs
+            .filter(({ max }) => typeof max !== 'number' || index < max)
+            .flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []));
+        if (next.length === 0) {
+            errors.invalidPath('missing-collection');
+            return null;
+        }
+        return walkPath(next, rest);
+    }
+    function checkCollectionBounds(collection) {
+        collectionConfigs(collection).forEach(({ min, max }) => {
+            if (typeof min !== 'number' || typeof max !== 'number') {
+                return;
+            }
+            if (min < 0 || max <= 0 || max < min) {
+                errors.invalidCollectionBounds(collection.name, min, max);
+            }
+        });
+    }
 }
-function collectionConfigs(collection, location) {
+function collectionConfigs(collection) {
     const { payload } = collection;
-    const payloadLocation = [...location, 'payload'];
     if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
-        return [[payload, payloadLocation]];
+        return [payload];
     }
     if (!check.is(BuilderWhenSerialisedSchema, payload)) {
         return [];
     }
     if (payload.type === 'match') {
-        return Object.entries(payload.selectMap).flatMap(([key, value]) => check.is(BuilderCollectionConfigSerialisedSchema, value)
-            ? [[value, [...payloadLocation, 'selectMap', key]]]
+        return Object.entries(payload.selectMap).flatMap(([, value]) => check.is(BuilderCollectionConfigSerialisedSchema, value)
+            ? [value]
             : []);
     }
     return check.is(BuilderCollectionConfigSerialisedSchema, payload.payload)
-        ? [[payload.payload, [...payloadLocation, 'payload']]]
+        ? [payload.payload]
         : [];
 }
-function extractWhenPaths(payload, location) {
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return [];
-    }
-    if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
-        return [[payload.matchPath, [...location, 'payload', 'matchPath']]];
-    }
-    if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
-        return [[payload.unlessPath, [...location, 'payload', 'unlessPath']]];
-    }
-    return [];
-}
-function walkPath(candidates, remaining, entryName, fullPath, location) {
-    if (remaining.length === 0) {
-        return [candidates, []];
-    }
-    const [collectionName, indexValue, ...rest] = remaining;
-    if (typeof collectionName !== 'string' || typeof indexValue !== 'number') {
-        return [[], [builderErrorInvalidPath('shape', location)]];
-    }
-    const [next, anyOutOfBounds] = candidates.reduce(([accumulator, anyOutOfBoundsAccumulator], current) => {
-        const collection = current.collections.find(({ name }) => name === collectionName);
-        if (collection == null) {
-            return [accumulator, anyOutOfBoundsAccumulator];
-        }
-        const configs = collectionConfigs(collection, []);
-        const withinBounds = configs.filter(([{ max }]) => typeof max !== 'number' || indexValue < max);
-        if (withinBounds.length === 0 && configs.length > 0) {
-            return [accumulator, true];
-        }
-        const reached = withinBounds.flatMap(([{ model: configModel }]) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
-        return [[...accumulator, ...reached], anyOutOfBoundsAccumulator];
-    }, [[], false]);
-    if (anyOutOfBounds) {
-        return [[], [builderErrorInvalidPath('out-of-bounds', location)]];
-    }
-    if (next.length === 0) {
-        return [[], [builderErrorInvalidPath('missing-collection', location)]];
-    }
-    return walkPath(next, rest, entryName, fullPath, location);
-}

package/dist/validate/pricing.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderPricingValidated } from '../entities/index';
+import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
+export type BuilderPricingValidationResult = ValidationResult<BuilderPricingValidated>;
+export declare function validatePricing(input: unknown, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
+export declare function validatePricingStructure(pricingInput: unknown, errors: BuilderValidateErrors): void;

package/dist/validate/pricing.js

@@ -0,0 +1,71 @@
+import { check } from '../check.js';
+import { BuilderPricingSchema } from '../entities/index.js';
+import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
+const EMPTY_PRICING = validate({
+    rates: {},
+    formula: { kind: 'num', value: 0 }
+});
+export function validatePricing(input, errors = new BuilderValidateErrors()) {
+    if (!check.is(BuilderPricingSchema, input)) {
+        errors.invalidInput('pricing');
+        return [EMPTY_PRICING, errors.errors];
+    }
+    validatePricingStructure(input, errors);
+    return [validate(input), errors.errors];
+}
+export function validatePricingStructure(pricingInput, errors) {
+    if (!check.is(BuilderPricingSchema, pricingInput)) {
+        return;
+    }
+    const pricing = pricingInput;
+    walkExpr(pricing.formula, false);
+    function walkExpr(expression, insideVariants) {
+        switch (expression.kind) {
+            case 'num':
+                return;
+            case 'variantPrice':
+                if (!insideVariants) {
+                    errors.invalidPricing('scope', 'variantPrice may only be used inside a variants.expression');
+                }
+                return;
+            case 'rate':
+                errors.scope('rate', () => {
+                    if (pricing.rates[expression.rate] == null) {
+                        errors.invalidPricing('missing-rate', `rate '${expression.rate}' is not defined`);
+                    }
+                    checkTagExpr(expression.tag, insideVariants);
+                });
+                return;
+            case 'variants':
+                errors.scope('variants', () => {
+                    if (insideVariants) {
+                        errors.invalidPricing('nested-variants', 'variants cannot nest inside variants');
+                    }
+                    const { tag } = expression;
+                    if (tag) {
+                        errors.scope('tag', () => checkFilterTagExpr(tag));
+                    }
+                    errors.scope('expression', () => walkExpr(expression.expression, true));
+                });
+                return;
+            case 'add':
+            case 'sub':
+            case 'mul':
+            case 'div':
+                errors.scope('left', () => walkExpr(expression.left, insideVariants));
+                errors.scope('right', () => walkExpr(expression.right, insideVariants));
+                return;
+        }
+    }
+    function checkTagExpr(tag, insideVariants) {
+        if (tag.kind === 'variantTags' && !insideVariants) {
+            errors.invalidPricing('scope', 'variantTags may only be used inside a variants.expression');
+        }
+    }
+    function checkFilterTagExpr(tag) {
+        if (tag.kind === 'variantTags') {
+            errors.invalidPricing('invalid-filter', 'variantTags is not a valid variants.tag filter');
+        }
+    }
+}

package/dist/validate/resolve.d.ts

@@ -1,16 +1,4 @@
 import type { BuilderBindings, BuilderRefEntities } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
-export declare function builderErrorUnboundParameter(name: string, location?: BuilderErrorLocation): {
-    name: string;
-    kind: "unbound-parameter";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnboundParameter = ReturnType<typeof builderErrorUnboundParameter>;
-export declare function builderErrorMissingReference(id: string, location?: BuilderErrorLocation): {
-    id: string;
-    kind: "missing-reference";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorMissingReference = ReturnType<typeof builderErrorMissingReference>;
-export type BuilderResolve = (value: unknown, location: BuilderErrorLocation) => readonly [unknown, BuilderErrors];
-export declare function resolver(references?: BuilderRefEntities, bindings?: BuilderBindings): BuilderResolve;
+import type { BuilderValidateErrors } from './errors';
+export type BuilderResolve = (value: unknown) => unknown;
+export declare function resolver(errors: BuilderValidateErrors, references?: BuilderRefEntities, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -1,89 +1,86 @@
 import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
-import { builderError } from '../exception.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
-export function builderErrorUnboundParameter(name, location = []) {
-    return { ...builderError('unbound-parameter', location), name };
-}
-export function builderErrorMissingReference(id, location = []) {
-    return { ...builderError('missing-reference', location), id };
-}
-export function resolver(references = [], bindings = {}) {
-    function resolve(value, location) {
+import { validateModelStructure } from './model.js';
+export function resolver(errors, references = [], bindings = {}) {
+    function resolve(value) {
         if (check.is(BuilderParameterSerialisedSchema, value)) {
-            return resolveParameter(value, location);
+            return resolveParameter(value);
         }
         if (check.is(BuilderRefSerialisedSchema, value)) {
-            return resolveReference(value, location);
+            return resolveReference(value);
         }
         if (check.is(BuilderWhenSerialisedSchema, value)) {
-            return resolveWhen(value, location);
+            return resolveWhen(value);
         }
         if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
-            return resolveCollectionConfig(value, location);
-        }
-        return [value, []];
-    }
-    function resolveReference(reference, location) {
-        const found = references.find((entry) => entry.id === reference.id);
-        if (found == null) {
-            return [reference, [builderErrorMissingReference(reference.id, location)]];
-        }
-        return [found.serialised, []];
-    }
-    function resolveParameter(parameter, location) {
-        if (!(parameter.name in bindings)) {
-            return [null, [builderErrorUnboundParameter(parameter.name, location)]];
-        }
-        const binding = bindings[parameter.name];
-        if (!check.is(BuilderRefSerialisedSchema, binding)) {
-            return [binding, []];
-        }
-        return resolveReference(binding, location);
-    }
-    function resolveWhen(when, location) {
-        if (when.type === 'enable') {
-            const [payload, errors] = resolve(when.payload, [...location, 'payload']);
-            return [{ ...when, payload: payload ?? when.payload }, errors];
+            return resolveCollectionConfig(value);
         }
-        if (when.type === 'unless') {
-            const [unlessPath, unlessErrors] = resolve(when.unlessPath, [...location, 'unlessPath']);
-            const [payload, payloadErrors] = resolve(when.payload, [...location, 'payload']);
-            return [
-                { ...when, unlessPath: unlessPath ?? when.unlessPath, payload: payload ?? when.payload },
-                [...unlessErrors, ...payloadErrors]
-            ];
+        return value;
+        function resolveReference(reference) {
+            const found = references.find((entry) => entry.id === reference.id);
+            if (found == null) {
+                errors.missingReference(reference.id);
+                return reference;
+            }
+            return found.serialised;
         }
-        const [matchPath, matchErrors] = resolve(when.matchPath, [...location, 'matchPath']);
-        const [map, mapErrors] = resolve(when.selectMap, [...location, 'selectMap']);
-        if (map == null || typeof map !== 'object') {
-            return [{ ...when, matchPath: matchPath ?? when.matchPath }, [...matchErrors, ...mapErrors]];
+        function resolveParameter(parameter) {
+            if (!(parameter.name in bindings)) {
+                errors.unboundParameter(parameter.name);
+                return null;
+            }
+            const binding = bindings[parameter.name];
+            if (!check.is(BuilderRefSerialisedSchema, binding)) {
+                return binding;
+            }
+            return resolveReference(binding);
         }
-        const [selectMap, entryErrors] = Object.entries(map).reduce(([values, errors], [key, entryValue]) => {
-            if (entryValue == null) {
-                return [{ ...values, [key]: null }, errors];
+        function resolveWhen(when) {
+            if (when.type === 'enable') {
+                const payload = errors.scope('payload', () => resolve(when.payload));
+                return { ...when, payload: payload ?? when.payload };
             }
-            const [resolved, resolvedErrors] = resolve(entryValue, [...location, 'selectMap', key]);
-            return [{ ...values, [key]: resolved ?? entryValue }, [...errors, ...resolvedErrors]];
-        }, [{}, []]);
-        return [
-            { ...when, matchPath: matchPath ?? when.matchPath, selectMap },
-            [...matchErrors, ...mapErrors, ...entryErrors]
-        ];
-    }
-    function resolveCollectionConfig(config, location) {
-        const [model, modelErrors] = resolve(config.model, [...location, 'model']);
-        const [min, minErrors] = resolve(config.min, [...location, 'min']);
-        const [max, maxErrors] = resolve(config.max, [...location, 'max']);
-        return [
-            {
+            if (when.type === 'unless') {
+                const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath));
+                const payload = errors.scope('payload', () => resolve(when.payload));
+                return {
+                    ...when,
+                    unlessPath: unlessPath ?? when.unlessPath,
+                    payload: payload ?? when.payload
+                };
+            }
+            const matchPath = errors.scope('matchPath', () => resolve(when.matchPath));
+            const map = errors.scope('selectMap', () => resolve(when.selectMap));
+            if (map == null || typeof map !== 'object') {
+                return { ...when, matchPath: matchPath ?? when.matchPath };
+            }
+            const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
+                if (entryValue == null) {
+                    return { ...values, [key]: null };
+                }
+                const resolved = errors.scope(key, () => resolve(entryValue));
+                return { ...values, [key]: resolved ?? entryValue };
+            }, {}));
+            return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+        }
+        function resolveCollectionConfig(config) {
+            const model = errors.scope('model', () => {
+                const resolved = resolve(config.model);
+                if (check.is(BuilderModelSerialisedSchema, resolved)) {
+                    return validateModelStructure(resolved, resolve, errors);
+                }
+                return resolved;
+            });
+            const min = errors.scope('min', () => resolve(config.min));
+            const max = errors.scope('max', () => resolve(config.max));
+            return {
                 ...config,
                 model: model ?? config.model,
                 min: min ?? config.min,
                 max: max ?? config.max
-            },
-            [...modelErrors, ...minErrors, ...maxErrors]
-        ];
+            };
+        }
     }
     return resolve;
 }

package/dist/validate/result.d.ts

@@ -1,8 +1,2 @@
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { BuilderErrors } from '../exception';
 export type ValidationResult<Entity> = readonly [Entity, BuilderErrors];
-export declare function builderErrorInvalidInput(target: 'builder' | 'model' | 'ui' | 'variants', location?: BuilderErrorLocation): {
-    target: "builder" | "model" | "ui" | "variants";
-    kind: "invalid-input";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidInput = ReturnType<typeof builderErrorInvalidInput>;