@builder-builder/builder 0.0.13 → 0.0.15

package/dist/mappers/variants/variants.js

@@ -24,10 +24,10 @@ function buildVariants(model) {
         ]))
     };
 }
-function optionGraph(model) {
+export function optionGraph(model) {
     return model.options.reduce((graph, option) => graph.add(option, model), new BuilderOptionGraph());
 }
-function variantsFor(entity, options) {
+export function variantsFor(entity, options) {
     const keys = new Set(dependencyKeys(entity.payload, entity.paths));
     const graphPaths = Array.from(keys)
         .map((key) => options.get(key))

package/dist/validate/brand.d.ts

@@ -1,14 +1,7 @@
-import type { BuilderErrorLocation } from '../exception';
 declare const VALIDATED: unique symbol;
 export type BuilderValidatedBrand = {
     readonly [VALIDATED]: true;
 };
-export declare function builderErrorUnvalidated(value: unknown, location?: BuilderErrorLocation): {
-    value: unknown;
-    kind: "unvalidated";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnvalidated = ReturnType<typeof builderErrorUnvalidated>;
 export declare function validate<Input extends object>(value: Input): Input & BuilderValidatedBrand;
 export declare function assertValidated<Input>(value: Input): asserts value is Input & BuilderValidatedBrand;
 export {};

package/dist/validate/brand.js

@@ -1,8 +1,6 @@
-import { builderError, BuilderException } from '../exception.js';
+import { BuilderException } from '../exception.js';
+import { BuilderValidateErrors } from './errors.js';
 const VALIDATED = Symbol('builder.validated');
-export function builderErrorUnvalidated(value, location = []) {
-    return { ...builderError('unvalidated', location), value };
-}
 export function validate(value) {
     // Descriptor flags chosen for Svelte 5 `$state` proxy compatibility — `$state`
     // rejects any property that isn't writable, configurable, and enumerable.
@@ -18,6 +16,8 @@ export function validate(value) {
 }
 export function assertValidated(value) {
     if (typeof value !== 'object' || value === null || !(VALIDATED in value)) {
-        throw new BuilderException([builderErrorUnvalidated(value)]);
+        const errors = new BuilderValidateErrors();
+        errors.unvalidated(value);
+        throw new BuilderException(errors.errors);
     }
 }

package/dist/validate/builder.d.ts

@@ -1,4 +1,5 @@
 import type { BuilderRefEntities, BuilderValidated } from '../entities/index';
 import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderValidationResult = ValidationResult<BuilderValidated>;
-export declare function validateBuilder(input: unknown, references?: BuilderRefEntities): BuilderValidationResult;
+export declare function validateBuilder(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderValidationResult;

package/dist/validate/builder.js

@@ -1,27 +1,33 @@
 import { check } from '../check.js';
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
 import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
+import { validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
-import { builderErrorInvalidInput } from './result.js';
 import { checkUIExpectations, validateUIStructure } from './ui.js';
-export function validateBuilder(input, references = []) {
+export function validateBuilder(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        const errors = [builderErrorInvalidInput('builder')];
-        return [validate(serialise.builder(builder())), errors];
+        errors.invalidInput('builder');
+        return [validate(serialise.builder(builder())), errors.errors];
     }
-    const resolve = resolver(references, input.bindings);
-    const [validatedModel, modelErrors] = validateModelStructure(input.model, resolve, ['model']);
-    const [validatedUI, uiErrors] = validateUIStructure(input.ui, resolve, ['ui']);
+    const resolve = resolver(errors, references, input.bindings);
+    const validatedModel = errors.scope('model', () => validateModelStructure(input.model, resolve, errors));
+    const validatedUI = errors.scope('ui', () => validateUIStructure(input.ui, resolve, errors));
     const mergedModel = modelsMerge(validatedModel);
-    const expectationErrors = [
-        ...checkModelExpectations(mergedModel, validatedModel, ['model']),
-        ...checkUIExpectations(mergedModel, validatedUI, ['ui'])
-    ];
+    errors.scope('model', () => {
+        checkModelExpectations(mergedModel, validatedModel, errors);
+    });
+    errors.scope('ui', () => {
+        checkUIExpectations(mergedModel, validatedUI, errors);
+    });
+    if (input.pricing) {
+        errors.scope('pricing', () => validatePricingStructure(resolve(input.pricing) ?? input.pricing, errors));
+    }
     const data = validate({
-        ...serialise.builder(builder()),
+        ...input,
         model: mergedModel,
         ui: validatedUI
     });
-    return [data, [...expectationErrors, ...modelErrors, ...uiErrors]];
+    return [data, errors.errors];
 }

package/dist/validate/errors.d.ts

@@ -0,0 +1,138 @@
+import type { BuilderExpectationKind } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { BuilderInstance } from '../instance';
+export type BuilderInvalidInputTarget = 'builder' | 'model' | 'pricing' | 'ui' | 'variants';
+export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
+export type BuilderErrorInvalidPricingReason = 'scope' | 'nested-variants' | 'missing-rate' | 'invalid-filter';
+export declare class BuilderValidateErrors {
+    #private;
+    get errors(): BuilderErrors;
+    scope<Result>(part: string | number, fn: () => Result): Result;
+    invalidInput(target: BuilderInvalidInputTarget): {
+        target: BuilderInvalidInputTarget;
+        kind: "invalid-input";
+        location: BuilderErrorLocation;
+    };
+    invalidOption(name: string, value: unknown): {
+        name: string;
+        value: unknown;
+        kind: "invalid-option";
+        location: BuilderErrorLocation;
+    };
+    invalidCollection(name: string): {
+        name: string;
+        kind: "invalid-collection";
+        location: BuilderErrorLocation;
+    };
+    duplicateName(name: string): {
+        name: string;
+        kind: "duplicate-name";
+        location: BuilderErrorLocation;
+    };
+    invalidCollectionBounds(name: string, min: number, max: number): {
+        name: string;
+        min: number;
+        max: number;
+        kind: "invalid-collection-bounds";
+        location: BuilderErrorLocation;
+    };
+    invalidPath(reason: BuilderErrorInvalidPathReason): {
+        reason: BuilderErrorInvalidPathReason;
+        kind: "invalid-path";
+        location: BuilderErrorLocation;
+    };
+    invalidSelectMapKey(key: string): {
+        key: string;
+        kind: "invalid-select-map-key";
+        location: BuilderErrorLocation;
+    };
+    unboundParameter(name: string): {
+        name: string;
+        kind: "unbound-parameter";
+        location: BuilderErrorLocation;
+    };
+    missingReference(id: string): {
+        id: string;
+        kind: "missing-reference";
+        location: BuilderErrorLocation;
+    };
+    unmetExpectation(expectationKind: BuilderExpectationKind, name: string): {
+        expectationKind: "option" | "component" | "collection";
+        name: string;
+        kind: "unmet-expectation";
+        location: BuilderErrorLocation;
+    };
+    unvalidated(value: unknown): {
+        value: unknown;
+        kind: "unvalidated";
+        location: BuilderErrorLocation;
+    };
+    missingComponent(component: string): {
+        component: string;
+        kind: "missing-component";
+        location: BuilderErrorLocation;
+    };
+    unexpectedComponent(component: string): {
+        component: string;
+        kind: "unexpected-component";
+        location: BuilderErrorLocation;
+    };
+    missingVariant(component: string, instance: BuilderInstance): {
+        component: string;
+        instance: BuilderInstance;
+        kind: "missing-variant";
+        location: BuilderErrorLocation;
+    };
+    invalidVariant(component: string, instance: BuilderInstance): {
+        component: string;
+        instance: BuilderInstance;
+        kind: "invalid-variant";
+        location: BuilderErrorLocation;
+    };
+    missingDetail(component: string, detail: string, instance: BuilderInstance): {
+        component: string;
+        detail: string;
+        instance: BuilderInstance;
+        kind: "missing-detail";
+        location: BuilderErrorLocation;
+    };
+    unexpectedDetail(component: string, detail: string, instance: BuilderInstance): {
+        component: string;
+        detail: string;
+        instance: BuilderInstance;
+        kind: "unexpected-detail";
+        location: BuilderErrorLocation;
+    };
+    invalidDetail(component: string, detail: string, instance: BuilderInstance): {
+        component: string;
+        detail: string;
+        instance: BuilderInstance;
+        kind: "invalid-detail";
+        location: BuilderErrorLocation;
+    };
+    invalidPricing(reason: BuilderErrorInvalidPricingReason, detail?: string): {
+        reason: BuilderErrorInvalidPricingReason;
+        detail: string | undefined;
+        kind: "invalid-pricing";
+        location: BuilderErrorLocation;
+    };
+}
+export type BuilderErrorInvalidInput = ReturnType<BuilderValidateErrors['invalidInput']>;
+export type BuilderErrorInvalidOption = ReturnType<BuilderValidateErrors['invalidOption']>;
+export type BuilderErrorInvalidCollection = ReturnType<BuilderValidateErrors['invalidCollection']>;
+export type BuilderErrorDuplicateName = ReturnType<BuilderValidateErrors['duplicateName']>;
+export type BuilderErrorInvalidCollectionBounds = ReturnType<BuilderValidateErrors['invalidCollectionBounds']>;
+export type BuilderErrorInvalidPath = ReturnType<BuilderValidateErrors['invalidPath']>;
+export type BuilderErrorInvalidSelectMapKey = ReturnType<BuilderValidateErrors['invalidSelectMapKey']>;
+export type BuilderErrorUnboundParameter = ReturnType<BuilderValidateErrors['unboundParameter']>;
+export type BuilderErrorMissingReference = ReturnType<BuilderValidateErrors['missingReference']>;
+export type BuilderErrorUnmetExpectation = ReturnType<BuilderValidateErrors['unmetExpectation']>;
+export type BuilderErrorUnvalidated = ReturnType<BuilderValidateErrors['unvalidated']>;
+export type BuilderErrorMissingComponent = ReturnType<BuilderValidateErrors['missingComponent']>;
+export type BuilderErrorUnexpectedComponent = ReturnType<BuilderValidateErrors['unexpectedComponent']>;
+export type BuilderErrorMissingVariant = ReturnType<BuilderValidateErrors['missingVariant']>;
+export type BuilderErrorInvalidVariant = ReturnType<BuilderValidateErrors['invalidVariant']>;
+export type BuilderErrorMissingDetail = ReturnType<BuilderValidateErrors['missingDetail']>;
+export type BuilderErrorUnexpectedDetail = ReturnType<BuilderValidateErrors['unexpectedDetail']>;
+export type BuilderErrorInvalidDetail = ReturnType<BuilderValidateErrors['invalidDetail']>;
+export type BuilderErrorInvalidPricing = ReturnType<BuilderValidateErrors['invalidPricing']>;

package/dist/validate/errors.js

@@ -0,0 +1,148 @@
+import { builderError } from '../exception.js';
+export class BuilderValidateErrors {
+    #errors = [];
+    #location = [];
+    get errors() {
+        return this.#errors;
+    }
+    scope(part, fn) {
+        this.#location = [...this.#location, part];
+        try {
+            return fn();
+        }
+        finally {
+            this.#location = this.#location.slice(0, -1);
+        }
+    }
+    invalidInput(target) {
+        return this.#addError({
+            ...builderError('invalid-input', this.#location),
+            target
+        });
+    }
+    invalidOption(name, value) {
+        return this.#addError({
+            ...builderError('invalid-option', this.#location),
+            name,
+            value
+        });
+    }
+    invalidCollection(name) {
+        return this.#addError({
+            ...builderError('invalid-collection', this.#location),
+            name
+        });
+    }
+    duplicateName(name) {
+        return this.#addError({
+            ...builderError('duplicate-name', this.#location),
+            name
+        });
+    }
+    invalidCollectionBounds(name, min, max) {
+        return this.#addError({
+            ...builderError('invalid-collection-bounds', this.#location),
+            name,
+            min,
+            max
+        });
+    }
+    invalidPath(reason) {
+        return this.#addError({
+            ...builderError('invalid-path', this.#location),
+            reason
+        });
+    }
+    invalidSelectMapKey(key) {
+        return this.#addError({
+            ...builderError('invalid-select-map-key', this.#location),
+            key
+        });
+    }
+    unboundParameter(name) {
+        return this.#addError({
+            ...builderError('unbound-parameter', this.#location),
+            name
+        });
+    }
+    missingReference(id) {
+        return this.#addError({
+            ...builderError('missing-reference', this.#location),
+            id
+        });
+    }
+    unmetExpectation(expectationKind, name) {
+        return this.#addError({
+            ...builderError('unmet-expectation', this.#location),
+            expectationKind,
+            name
+        });
+    }
+    unvalidated(value) {
+        return this.#addError({
+            ...builderError('unvalidated', this.#location),
+            value
+        });
+    }
+    missingComponent(component) {
+        return this.#addError({
+            ...builderError('missing-component', this.#location),
+            component
+        });
+    }
+    unexpectedComponent(component) {
+        return this.#addError({
+            ...builderError('unexpected-component', this.#location),
+            component
+        });
+    }
+    missingVariant(component, instance) {
+        return this.#addError({
+            ...builderError('missing-variant', this.#location),
+            component,
+            instance
+        });
+    }
+    invalidVariant(component, instance) {
+        return this.#addError({
+            ...builderError('invalid-variant', this.#location),
+            component,
+            instance
+        });
+    }
+    missingDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('missing-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    unexpectedDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('unexpected-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    invalidDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('invalid-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    invalidPricing(reason, detail) {
+        return this.#addError({
+            ...builderError('invalid-pricing', this.#location),
+            reason,
+            detail
+        });
+    }
+    #addError(error) {
+        this.#errors = [...this.#errors, error];
+        return error;
+    }
+}

package/dist/validate/expectations.d.ts

@@ -1,10 +1,3 @@
-import type { BuilderExpectationKind, BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
-export declare function builderErrorUnmetExpectation(expectationKind: BuilderExpectationKind, name: string, location?: BuilderErrorLocation): {
-    expectationKind: "option" | "component" | "collection";
-    name: string;
-    kind: "unmet-expectation";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnmetExpectation = ReturnType<typeof builderErrorUnmetExpectation>;
-export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, location: BuilderErrorLocation): BuilderErrors;
+import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderValidateErrors } from './errors';
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/expectations.js

@@ -1,12 +1,10 @@
-import { builderError } from '../exception.js';
-export function builderErrorUnmetExpectation(expectationKind, name, location = []) {
-    return { ...builderError('unmet-expectation', location), expectationKind, name };
-}
-export function checkExpectations(model, expectations, location) {
-    return expectations.flatMap(({ kind, name }, index) => {
-        if (model[`${kind}s`].some((entry) => entry.name === name)) {
-            return [];
-        }
-        return [builderErrorUnmetExpectation(kind, name, [...location, index])];
+export function checkExpectations(model, expectations, errors) {
+    expectations.forEach(({ kind, name }, index) => {
+        errors.scope(index, () => {
+            if (model[`${kind}s`].some((entry) => entry.name === name)) {
+                return;
+            }
+            errors.unmetExpectation(kind, name);
+        });
     });
 }

package/dist/validate/index.d.ts

@@ -1,18 +1,14 @@
-export type { BuilderErrorUnvalidated } from './brand';
 export type { BuilderValidationResult } from './builder';
-export type { BuilderErrorUnmetExpectation } from './expectations';
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderInstanceValidationResult } from './instance';
-export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderModelValidationResult } from './model';
-export type { BuilderErrorMissingReference, BuilderErrorUnboundParameter } from './resolve';
-export type { BuilderErrorInvalidInput } from './result';
+export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidPricingReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInvalidInputTarget } from './errors';
+export type { BuilderInstanceValidationResult } from './instance';
+export type { BuilderModelValidationResult } from './model';
+export type { BuilderPricingValidationResult } from './pricing';
 export type { BuilderUIValidationResult } from './ui';
-export type { BuilderComponentVariantsValidationResult, BuilderErrorInvalidDetail, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderVariantsValidationOptions } from './variants';
-export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export type { BuilderComponentVariantsValidationResult, BuilderVariantsValidationOptions } from './variants';
+export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
-export { builderErrorUnmetExpectation } from './expectations.js';
-export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
-export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
-export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
-export { builderErrorInvalidInput } from './result.js';
+export { validateInstance } from './instance.js';
+export { validateModel } from './model.js';
+export { validatePricing } from './pricing.js';
 export { validateUI } from './ui.js';
-export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';
+export { validateVariants } from './variants.js';

package/dist/validate/index.js

@@ -1,9 +1,7 @@
-export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
-export { builderErrorUnmetExpectation } from './expectations.js';
-export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
-export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
-export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
-export { builderErrorInvalidInput } from './result.js';
+export { validateInstance } from './instance.js';
+export { validateModel } from './model.js';
+export { validatePricing } from './pricing.js';
 export { validateUI } from './ui.js';
-export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';
+export { validateVariants } from './variants.js';

package/dist/validate/instance.d.ts

@@ -1,19 +1,6 @@
 import type { BuilderInstanceValidated, BuilderModelValidated } from '../entities/index';
-import type { BuilderErrorLocation } from '../exception';
 import type { BuilderInstance } from '../instance';
 import type { ValidationResult } from './result';
-export declare function builderErrorInvalidOption(name: string, value: unknown, location?: BuilderErrorLocation): {
-    name: string;
-    value: unknown;
-    kind: "invalid-option";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidOption = ReturnType<typeof builderErrorInvalidOption>;
-export declare function builderErrorInvalidCollection(name: string, location?: BuilderErrorLocation): {
-    name: string;
-    kind: "invalid-collection";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidCollection = ReturnType<typeof builderErrorInvalidCollection>;
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
-export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance): BuilderInstanceValidationResult;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderValidateErrors): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,47 +1,48 @@
 import { check } from '../check.js';
 import { optionValueSchema } from '../entities/index.js';
-import { builderError } from '../exception.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function builderErrorInvalidOption(name, value, location = []) {
-    return { ...builderError('invalid-option', location), name, value };
-}
-export function builderErrorInvalidCollection(name, location = []) {
-    return { ...builderError('invalid-collection', location), name };
-}
-export function validateInstance(model, instance) {
-    const errors = checkInstance(model, instance, ['instance']);
-    return [validate(instance), errors];
-}
-function checkInstance(model, instance, location) {
-    const { options, collections } = model;
-    const optionErrors = options.flatMap((option) => {
-        const { name } = option;
-        const payload = resolveOption(option, model, instance);
-        if (!payload) {
-            return [];
-        }
-        const value = instance[name];
-        if (!check.is(optionValueSchema(payload), value)) {
-            return [builderErrorInvalidOption(name, value, [...location, name])];
-        }
-        return [];
-    });
-    const collectionErrors = collections.flatMap((collection) => {
-        const { name } = collection;
-        const payload = resolveCollection(collection, model, instance);
-        if (!payload) {
-            return [];
-        }
-        const existing = instance[name];
-        if (!check.is(BuilderInstancesSchema, existing)) {
-            return [builderErrorInvalidCollection(name, [...location, name])];
-        }
-        return existing.flatMap((itemInstance, index) => checkInstance(payload.model, itemInstance, [...location, name, index]).map((error) => ({
-            ...error,
-            name: `${name}[${index}].${error.name}`
-        })));
+import { BuilderValidateErrors } from './errors.js';
+export function validateInstance(model, instance, errors = new BuilderValidateErrors()) {
+    errors.scope('instance', () => {
+        checkInstance(model, instance);
     });
-    return [...optionErrors, ...collectionErrors];
+    return [validate(instance), errors.errors];
+    function checkInstance(scopeModel, scopeInstance, namePrefix = '') {
+        scopeModel.options.forEach((option) => {
+            const { name } = option;
+            const payload = resolveOption(option, scopeModel, scopeInstance);
+            if (!payload) {
+                return;
+            }
+            const value = scopeInstance[name];
+            if (!check.is(optionValueSchema(payload), value)) {
+                errors.scope(name, () => {
+                    errors.invalidOption(`${namePrefix}${name}`, value);
+                });
+            }
+        });
+        scopeModel.collections.forEach((collection) => {
+            const { name } = collection;
+            const payload = resolveCollection(collection, scopeModel, scopeInstance);
+            if (!payload) {
+                return;
+            }
+            const existing = scopeInstance[name];
+            if (!check.is(BuilderInstancesSchema, existing)) {
+                errors.scope(name, () => {
+                    errors.invalidCollection(`${namePrefix}${name}`);
+                });
+                return;
+            }
+            errors.scope(name, () => {
+                existing.forEach((itemInstance, index) => {
+                    errors.scope(index, () => {
+                        checkInstance(payload.model, itemInstance, `${namePrefix}${name}[${index}].`);
+                    });
+                });
+            });
+        });
+    }
 }

package/dist/validate/model.d.ts

@@ -1,36 +1,9 @@
 import type { BuilderModelSerialised, BuilderModelValidated, BuilderRefEntities } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
 import type { ParamableSerialised } from '../references';
 import type { BuilderResolve } from './resolve';
 import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
-export declare function builderErrorDuplicateName(name: string, location?: BuilderErrorLocation): {
-    name: string;
-    kind: "duplicate-name";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorDuplicateName = ReturnType<typeof builderErrorDuplicateName>;
-export declare function builderErrorInvalidCollectionBounds(name: string, min: number, max: number, location?: BuilderErrorLocation): {
-    name: string;
-    min: number;
-    max: number;
-    kind: "invalid-collection-bounds";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidCollectionBounds = ReturnType<typeof builderErrorInvalidCollectionBounds>;
-export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
-export declare function builderErrorInvalidPath(reason: BuilderErrorInvalidPathReason, location?: BuilderErrorLocation): {
-    reason: BuilderErrorInvalidPathReason;
-    kind: "invalid-path";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidPath = ReturnType<typeof builderErrorInvalidPath>;
-export declare function builderErrorInvalidSelectMapKey(key: string, location?: BuilderErrorLocation): {
-    key: string;
-    kind: "invalid-select-map-key";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidSelectMapKey = ReturnType<typeof builderErrorInvalidSelectMapKey>;
-export declare function validateModel(input: unknown, references?: BuilderRefEntities): BuilderModelValidationResult;
-export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, model: BuilderModelSerialised, location: BuilderErrorLocation): BuilderErrors;
-export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, location: BuilderErrorLocation): BuilderModelValidationResult;
+export declare function validateModel(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, errors: BuilderValidateErrors): void;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderModelValidated;