@builder-builder/builder 0.0.24 → 0.0.25

package/dist/mappers/resolve.js

@@ -27,12 +27,12 @@ export function resolveReference(value, references) {
         return value;
     }
     const found = references.find((entry) => entry.id === value.id);
-    check.truthy(found, `Reference '${value.id}' not found! ❌`);
+    check.invariant(found);
     return found.serialised;
 }
 export function resolvePath(model, instance, path, references = []) {
     const optionName = path.at(-1);
-    check.assert(v.string(), optionName, 'Path must end at an option name! ❌');
+    check.assert(v.string(), optionName);
     const descended = resolveItems(model, instance, path.slice(0, -1), references);
     if (descended == null) {
         return null;
@@ -40,7 +40,7 @@ export function resolvePath(model, instance, path, references = []) {
     const [scopeModel, scopeInstance] = descended;
     const merged = modelsMerge(scopeModel);
     const option = merged.options.find((entry) => entry.name === optionName);
-    check.truthy(option, `Path target '${optionName}' is not an option! ❌`);
+    check.invariant(option);
     const payload = resolveOption(option, scopeModel, scopeInstance, references);
     if (payload == null) {
         return null;
@@ -54,10 +54,10 @@ export function resolveItems(model, instance, pairs, references = []) {
     }
     const [name, index, ...rest] = pairs;
     check.assert(v.string(), name);
-    check.assert(v.number(), index, `Collection '${name}' must be followed by an index! ❌`);
+    check.assert(v.number(), index);
     const merged = modelsMerge(model);
     const collection = merged.collections.find((entry) => entry.name === name);
-    check.truthy(collection, `Path segment '${name}' is not a collection! ❌`);
+    check.invariant(collection);
     const resolved = resolveCollection(collection, model, instance, references);
     if (resolved == null) {
         return null;

package/dist/mappers/variants/option-graph.js

@@ -2,7 +2,14 @@ import { BuilderPathSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } fr
 import { check } from '../../errors/index.js';
 import { resolveOption } from '../resolve.js';
 export function crossProduct(left, right) {
-    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+    return left.flatMap((leftModel) => right.flatMap((rightModel) => {
+        const rightKeys = new Set(Object.keys(rightModel));
+        const conflicted = Object.keys(leftModel).some((key) => rightKeys.has(key) && leftModel[key] !== rightModel[key]);
+        if (conflicted) {
+            return [];
+        }
+        return [{ ...leftModel, ...rightModel }];
+    }));
 }
 export function dependencyKeys(payload, paths = []) {
     const keys = new Set(paths.map(([first]) => String(first)));
@@ -25,7 +32,7 @@ export class BuilderOptionGraph {
     }
     get(name) {
         const graphPath = this.paths.find((graphPath) => graphPath.name === name);
-        check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
+        check.invariant(graphPath);
         return graphPath;
     }
     add(option, model) {
@@ -33,7 +40,7 @@ export class BuilderOptionGraph {
         const optionDependencyKeys = dependencyKeys(payload, paths);
         if (optionDependencyKeys.length === 0) {
             const payload = resolveOption(option, model, {});
-            check.truthy(payload, `Option '${option.name}' without dependencies must resolve! ❌`);
+            check.invariant(payload);
             const values = this.#optionValues(option.name, payload);
             return new BuilderOptionGraph([
                 ...this.paths,
@@ -65,7 +72,7 @@ export class BuilderOptionGraph {
     #mergePaths(dependencyKeys, graphPaths) {
         const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
             const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
-            check.truthy(dependencyPath, `Option dependency '${dependencyKey}' not found in graph! ❌`);
+            check.invariant(dependencyPath);
             return dependencyPath;
         });
         const [first, ...rest] = dependencyPaths;

package/dist/mappers/variants/variants.js

@@ -1,4 +1,4 @@
-import { BuilderModelSerialisedSchema, BuilderSerialisedSchema } from '../../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderSerialisedSchema, modelsMerge } from '../../entities/index.js';
 import { check } from '../../errors/index.js';
 import { resolveCollection } from '../resolve.js';
 import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
@@ -7,9 +7,10 @@ export function createVariants(entity) {
     return buildVariants(model);
 }
 function buildVariants(model) {
-    const options = optionGraph(model);
-    const nestedVariants = model.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
-        const resolved = resolveCollection(entry, model, instance);
+    const merged = modelsMerge(model);
+    const options = optionGraph(merged);
+    const nestedVariants = merged.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
+        const resolved = resolveCollection(entry, merged, instance);
         if (resolved == null) {
             return [];
         }
@@ -17,8 +18,8 @@ function buildVariants(model) {
         return [buildVariants(resolved.model)];
     }));
     return {
-        ...nestedVariants.reduce((merged, component) => ({ ...merged, ...component }), {}),
-        ...Object.fromEntries(model.components.map((component) => [
+        ...nestedVariants.reduce((accumulated, component) => ({ ...accumulated, ...component }), {}),
+        ...Object.fromEntries(merged.components.map((component) => [
             component.name,
             variantsFor(component, options).map((instance) => ({ instance }))
         ]))

package/dist/public.d.ts

@@ -0,0 +1,37 @@
+export type { BB, BBOptions, BuilderEntityValidators } from './bb';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { BuilderEnvironment } from './environment';
+export type { BuilderError, BuilderErrorLocation, BuilderErrors } from './errors/index';
+export type { BuilderErrorKind } from './errors/index.js';
+export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariants } from './instance';
+export type { BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
+export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
+export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
+export type { BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';
+export { bb } from './bb.js';
+export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './errors/index.js';
+export { ordinal } from './mappers/index.js';
+export { parameter, ref } from './references.js';
+import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, optionExpectation, uis } from './entities/index.js';
+export declare const collection: typeof collectionConfig & {
+    enable: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+};
+export declare const component: typeof componentConfig & {
+    enable: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(payload?: Payload) => import("./public").BuilderEnableConfig<Payload>;
+    match: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>, const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./public").BuilderUnlessConfig<Payload, UnlessPath>;
+};
+export declare const has: {
+    collection: typeof collectionExpectation;
+    component: typeof componentExpectation;
+    option: typeof optionExpectation;
+};
+export declare const option: {
+    enable: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+};
+export declare const ui: typeof uis;

package/dist/public.js

@@ -0,0 +1,19 @@
+export { bb } from './bb.js';
+export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './errors/index.js';
+export { ordinal } from './mappers/index.js';
+export { parameter, ref } from './references.js';
+import { collectionConfig, collectionExpectation, collectionWhen, componentConfig, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';
+export const collection = Object.assign(collectionConfig, {
+    ...collectionWhen
+});
+export const component = Object.assign(componentConfig, {
+    ...componentWhen
+});
+export const has = {
+    collection: collectionExpectation,
+    component: componentExpectation,
+    option: optionExpectation
+};
+export const option = optionWhen;
+export const ui = uis;

package/dist/validate/brand.js

@@ -1,4 +1,4 @@
-import { BuilderException, BuilderValidateErrors } from '../errors/index.js';
+import { BuilderException } from '../errors/index.js';
 const VALIDATED_ENTITIES = new WeakSet();
 export function validate(value) {
     VALIDATED_ENTITIES.add(value);
@@ -6,8 +6,6 @@ export function validate(value) {
 }
 export function assertValidated(value) {
     if (typeof value !== 'object' || value === null || !VALIDATED_ENTITIES.has(value)) {
-        const errors = new BuilderValidateErrors();
-        errors.unvalidated(value);
-        throw new BuilderException({ category: 'validation', errors: errors.errors });
+        throw new BuilderException({ category: 'invariant', value });
     }
 }

package/dist/validate/builder.d.ts

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

package/dist/validate/builder.js

@@ -1,14 +1,14 @@
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { validate } from './brand.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
 import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
 import { checkUIExpectations, validateUIStructure } from './ui.js';
 const EMPTY_BUILDER = validate(serialise.builder(builder()));
-export function validateBuilder(input, references = [], errors = new BuilderValidateErrors()) {
+export function validateBuilder(input, references = [], errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        errors.invalidEntity('builder');
+        errors.entityInvalid('builder');
         return [EMPTY_BUILDER, errors.errors];
     }
     const resolve = resolver(errors, references, input.bindings);

package/dist/validate/expectations.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderValidateErrors } from '../errors/index';
-export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderValidateErrors): void;
+import type { BuilderErrorsScope } from '../errors/index';
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderErrorsScope): void;

package/dist/validate/expectations.js

@@ -4,7 +4,7 @@ export function checkExpectations(model, expectations, errors) {
             if (model[`${kind}s`].some((entry) => entry.name === name)) {
                 return;
             }
-            errors.unmetExpectation(kind, name);
+            errors.modelUnmetExpectation();
         });
     });
 }

package/dist/validate/index.d.ts

@@ -1,5 +1,4 @@
 export type { BuilderValidatedMap, ValidationResult } from '../entities/index';
-export type { BuilderErrorKind, BuilderValidateErrors } from '../errors/index';
 export type { BuilderValidatedBrand } from './brand';
 export type { BuilderValidationResult } from './builder';
 export type { BuilderInstanceValidationResult } from './instance';

package/dist/validate/instance.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderInstanceValidated, BuilderModelValidated, ValidationResult } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-import { BuilderValidateErrors } from '../errors/index.js';
+import { BuilderErrorsScope } from '../errors/index.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
-export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderValidateErrors): BuilderInstanceValidationResult;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderErrorsScope): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,14 +1,14 @@
 import { optionValueSchema } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function validateInstance(model, instance, errors = new BuilderValidateErrors()) {
+export function validateInstance(model, instance, errors = new BuilderErrorsScope(instance)) {
     errors.scope('instance', () => {
         checkInstance(model, instance);
     });
     return [validate(instance), errors.errors];
-    function checkInstance(scopeModel, scopeInstance, namePrefix = '') {
+    function checkInstance(scopeModel, scopeInstance) {
         scopeModel.options.forEach((option) => {
             const { name } = option;
             const payload = resolveOption(option, scopeModel, scopeInstance);
@@ -18,7 +18,7 @@ export function validateInstance(model, instance, errors = new BuilderValidateEr
             const value = scopeInstance[name];
             if (!check.is(optionValueSchema(payload), value)) {
                 errors.scope(name, () => {
-                    errors.invalidOption(`${namePrefix}${name}`, value);
+                    errors.instanceInvalidOption();
                 });
             }
         });
@@ -31,14 +31,14 @@ export function validateInstance(model, instance, errors = new BuilderValidateEr
             const existing = scopeInstance[name];
             if (!check.is(BuilderInstancesSchema, existing)) {
                 errors.scope(name, () => {
-                    errors.invalidCollection(`${namePrefix}${name}`);
+                    errors.instanceInvalidCollection();
                 });
                 return;
             }
             errors.scope(name, () => {
                 existing.forEach((itemInstance, index) => {
                     errors.scope(index, () => {
-                        checkInstance(payload.model, itemInstance, `${namePrefix}${name}[${index}].`);
+                        checkInstance(payload.model, itemInstance);
                     });
                 });
             });

package/dist/validate/model.d.ts

@@ -1,8 +1,8 @@
 import type { BuilderModelSerialised, BuilderModelValidated, BuilderReferences, ValidationResult } from '../entities/index';
 import type { ParamableSerialised } from '../references';
 import type { BuilderResolve } from './resolve';
-import { BuilderValidateErrors } from '../errors/index.js';
+import { BuilderErrorsScope } from '../errors/index.js';
 export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
-export declare function validateModel(input: unknown, references?: BuilderReferences, 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;
+export declare function validateModel(input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, errors: BuilderErrorsScope): void;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, errors: BuilderErrorsScope): BuilderModelValidated;

package/dist/validate/model.js

@@ -1,19 +1,20 @@
 import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { isParamable } from '../references.js';
 import { validate } from './brand.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 const EMPTY_MODEL = validate(serialise.model(model()));
-export function validateModel(input, references = [], errors = new BuilderValidateErrors()) {
+export function validateModel(input, references = [], errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        errors.invalidEntity('model');
+        errors.entityInvalid('model');
         return [EMPTY_MODEL, errors.errors];
     }
     const resolve = resolver(errors, references);
     const structure = validateModelStructure(input, resolve, errors);
-    const data = validate(modelsMerge(structure));
+    const merged = modelsMerge(structure);
+    const data = validate(merged);
     checkModelExpectations(data, structure, errors);
     return [data, errors.errors];
 }
@@ -33,111 +34,127 @@ export function checkModelExpectations(mergedModel, rootModel, errors) {
     }
 }
 export function validateModelStructure(input, resolve, errors) {
-    const resolved = resolve(input);
-    if (!check.is(BuilderModelSerialisedSchema, resolved)) {
-        return validate(serialise.model(model()));
-    }
-    const modelInput = resolved;
-    const skipPathValidation = modelInput.expectations.length > 0;
-    const childModels = errors.scope('models', () => modelInput.models.flatMap((part, partIndex) => errors.scope(partIndex, () => [validateModelStructure(part, resolve, errors)])));
-    const options = errors.scope('options', () => walkEntries(modelInput.options, (resolved) => {
-        whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
-            .filter((config) => !isParamable(config))
-            .forEach((config) => {
-            if (config.type === 'select') {
-                validateSelect(config, [], errors);
-            }
-            else if (config.type === 'toggle') {
-                validateToggle(config, [], errors);
-            }
-        });
-    }));
-    const components = errors.scope('components', () => walkEntries(modelInput.components, (resolved) => {
-        whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
-            .filter((config) => !isParamable(config))
-            .forEach((config) => {
-            validateComponentConfig(config, [], errors);
-        });
-    }));
-    const collections = errors.scope('collections', () => walkEntries(modelInput.collections, (resolved) => {
-        whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
-            .filter((config) => !isParamable(config))
-            .forEach((config) => {
-            validateCollectionConfig(config, [], errors);
-        });
-    }));
-    return {
-        ...modelInput,
-        models: childModels,
-        options,
-        components,
-        collections
+    const seenGlobal = {
+        option: new Set(),
+        component: new Set(),
+        collection: new Set()
     };
-    function walkEntries(entries, validateBranches) {
-        const seen = new Set();
-        const items = [];
-        entries.forEach((entry, entryIndex) => {
-            errors.scope(entryIndex, () => {
-                const resolved = resolveEntry(entry, seen);
-                if (resolved == null) {
-                    return;
+    return walkStructure(input);
+    function walkStructure(input) {
+        const resolved = resolve(input);
+        if (!check.is(BuilderModelSerialisedSchema, resolved)) {
+            return validate(serialise.model(model()));
+        }
+        const modelInput = resolved;
+        const skipPathValidation = modelInput.expectations.length > 0;
+        const childModels = errors.scope('models', () => modelInput.models.flatMap((part, partIndex) => errors.scope(partIndex, () => [walkStructure(part)])));
+        const options = errors.scope('options', () => walkEntries(modelInput.options, 'option', (resolved) => {
+            whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
+                .filter((config) => !isParamable(config))
+                .forEach((config) => {
+                if (config.type === 'select') {
+                    validateSelect(config, [], errors);
+                }
+                else if (config.type === 'toggle') {
+                    validateToggle(config, [], errors);
                 }
-                validateBranches(resolved);
-                items.push(resolved);
             });
-        });
-        return items;
-    }
-    function resolveEntry(entry, seen) {
-        let paths = entry.paths;
-        if (entry.paths != null) {
-            const resolvedPaths = errors.scope('paths', () => resolve(entry.paths));
-            paths = resolvedPaths ?? entry.paths;
-        }
-        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;
-        }
-        const { paths, payload } = entry;
-        if (Array.isArray(paths)) {
-            errors.scope('paths', () => {
-                paths.forEach((path, pathIndex) => {
-                    errors.scope(pathIndex, () => {
-                        checkPath(modelInput, path, errors);
-                    });
-                });
+        }));
+        const components = errors.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
+            whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
+                .filter((config) => !isParamable(config))
+                .forEach((config) => {
+                validateComponentConfig(config, [], errors);
             });
-        }
-        checkWhenPaths(payload);
-    }
-    function checkWhenPaths(payload) {
-        if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-            return;
-        }
-        if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
-            errors.scope('payload', () => {
-                errors.scope('matchPath', () => {
-                    checkPath(modelInput, payload.matchPath, errors);
+        }));
+        const collections = errors.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
+            whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
+                .filter((config) => !isParamable(config))
+                .forEach((config) => {
+                validateCollectionConfig(config, [], errors);
+            });
+        }));
+        return {
+            ...modelInput,
+            models: childModels,
+            options,
+            components,
+            collections
+        };
+        function walkEntries(entries, kind, validateBranches) {
+            const seenLocal = new Set();
+            const items = [];
+            entries.forEach((entry, entryIndex) => {
+                errors.scope(entryIndex, () => {
+                    const resolved = resolveEntry(entry, seenLocal, kind);
+                    if (resolved == null) {
+                        return;
+                    }
+                    validateBranches(resolved);
+                    items.push(resolved);
                 });
             });
-            return;
+            return items;
+        }
+        function resolveEntry(entry, seenLocal, kind) {
+            let paths = entry.paths;
+            if (entry.paths != null) {
+                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths));
+                paths = resolvedPaths ?? entry.paths;
+            }
+            const payload = errors.scope('payload', () => resolve(entry.payload));
+            const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
+            if (seenLocal.has(resolvedEntry.name)) {
+                if (kind === 'option') {
+                    errors.modelDuplicateOption();
+                }
+                else if (kind === 'component') {
+                    errors.modelDuplicateComponent();
+                }
+                else {
+                    errors.modelDuplicateCollection();
+                }
+                return null;
+            }
+            if (seenGlobal[kind].has(resolvedEntry.name)) {
+                if (kind === 'option') {
+                    errors.modelOverriddenOption();
+                }
+                else if (kind === 'component') {
+                    errors.modelOverriddenComponent();
+                }
+                else {
+                    errors.modelOverriddenCollection();
+                }
+            }
+            seenLocal.add(resolvedEntry.name);
+            seenGlobal[kind].add(resolvedEntry.name);
+            checkPaths(resolvedEntry);
+            return resolvedEntry;
         }
-        if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
-            errors.scope('payload', () => {
-                errors.scope('unlessPath', () => {
-                    checkPath(modelInput, payload.unlessPath, errors);
+        function checkPaths(entry) {
+            if (skipPathValidation) {
+                return;
+            }
+            const { paths, payload } = entry;
+            if (Array.isArray(paths)) {
+                errors.scope('paths', () => {
+                    paths.forEach((path, pathIndex) => {
+                        errors.scope(pathIndex, () => {
+                            checkPath(modelInput, path, errors);
+                        });
+                    });
                 });
-            });
+            }
+            if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+                return;
+            }
+            if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
+                errors.scope('payload', () => errors.scope('matchPath', () => checkPath(modelInput, payload.matchPath, errors)));
+            }
+            if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
+                errors.scope('payload', () => errors.scope('unlessPath', () => checkPath(modelInput, payload.unlessPath, errors)));
+            }
         }
     }
 }

package/dist/validate/paths.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderModelSerialised, BuilderPath } from '../entities/index';
-import type { BuilderValidateErrors } from '../errors/index';
-export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderValidateErrors): void;
+import type { BuilderErrorsScope } from '../errors/index';
+export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderErrorsScope): void;