@builder-builder/builder 0.0.24 → 0.0.26

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, BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderOptionUpdate, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } 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/references.d.ts

@@ -9,8 +9,8 @@ export declare class BuilderParameter<const Name extends string = string> {
 export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
 export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
@@ -25,7 +25,7 @@ export declare class BuilderRef {
 export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
 export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;
@@ -35,15 +35,15 @@ export declare function parameter<const Name extends string>(name: Name): Builde
 export declare function ref(id: string): BuilderRef;
 export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
     name: string;
 }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;

package/dist/references.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { check } from './errors/index.js';
+import { IdSchema, NameSchema } from './primitive.js';
 export class BuilderParameter {
     id;
     name;
@@ -9,7 +10,7 @@ export class BuilderParameter {
     }
 }
 export const BuilderParameterSchema = v.instance(BuilderParameter);
-export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: IdSchema, name: NameSchema }), v.readonly());
 export class BuilderRef {
     type = 'ref';
     id;
@@ -18,7 +19,7 @@ export class BuilderRef {
     }
 }
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string() }), v.readonly());
+export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: IdSchema }), v.readonly());
 export function parameter(name) {
     return new BuilderParameter(name);
 }

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,21 @@
-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 * as v from 'valibot';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/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 +35,137 @@ 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, BuilderModelSerialisedSchema);
+        if (resolved == null) {
+            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);
             });
+        }));
+        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 payloadSchemaFor(kind) {
+            if (kind === 'option') {
+                return BuilderOptionConfigSerialisedSchema;
+            }
+            if (kind === 'component') {
+                return BuilderComponentConfigSerialisedSchema;
+            }
+            return BuilderCollectionConfigSerialisedSchema;
         }
-        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);
+        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;
         }
-        if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
-            errors.scope('payload', () => {
-                errors.scope('unlessPath', () => {
-                    checkPath(modelInput, payload.unlessPath, errors);
+        function resolveEntry(entry, seenLocal, kind) {
+            let paths = entry.paths;
+            if (entry.paths != null) {
+                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
+                paths = resolvedPaths ?? entry.paths;
+            }
+            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderWhenSerialisedSchema]);
+            const payload = errors.scope('payload', () => resolve(entry.payload, payloadSchema));
+            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;
+        }
+        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;