@builder-builder/builder 0.0.19 → 0.0.21

package/dist/mappers/resolve.js

@@ -1,40 +1,39 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderOptionValuesSerialisedSchema, BuilderWhenSerialisedSchema, modelsMerge } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, modelsMerge, whenBranches } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
-import { BuilderPathsSchema } from '../paths.js';
 import { BuilderPrimitiveSchema } from '../primitive.js';
 import { BuilderRefSerialisedSchema } from '../references.js';
-export function resolveOption(option, model, instance, refs = []) {
-    return resolveEntryInstance(option, BuilderOptionValuesSerialisedSchema, model, instance, refs);
+export function resolveOption(option, model, instance, references = []) {
+    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, model, instance, references);
 }
-export function resolveOptions(option, refs = []) {
-    return resolveEntryExhaustive(option, BuilderOptionValuesSerialisedSchema, refs);
+export function resolveOptions(option, references = []) {
+    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, references);
 }
-export function resolveComponent(component, model, instance, refs = []) {
-    return resolveEntryInstance(component, BuilderComponentDetailsSerialisedSchema, model, instance, refs);
+export function resolveComponent(component, model, instance, references = []) {
+    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, model, instance, references);
 }
-export function resolveComponents(component, refs = []) {
-    return resolveEntryExhaustive(component, BuilderComponentDetailsSerialisedSchema, refs);
+export function resolveComponents(component, references = []) {
+    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, references);
 }
-export function resolveCollection(collection, model, instance, refs = []) {
-    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, model, instance, refs);
+export function resolveCollection(collection, model, instance, references = []) {
+    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, model, instance, references);
 }
-export function resolveCollections(collection, refs = []) {
-    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, refs);
+export function resolveCollections(collection, references = []) {
+    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, references);
 }
-export function resolveRef(value, refs) {
+export function resolveReference(value, references) {
     if (!check.is(BuilderRefSerialisedSchema, value)) {
         return value;
     }
-    const found = refs.find((entry) => entry.id === value.id);
+    const found = references.find((entry) => entry.id === value.id);
     check.truthy(found, `Reference '${value.id}' not found! ❌`);
     return found.serialised;
 }
-export function resolvePath(model, instance, path, refs = []) {
+export function resolvePath(model, instance, path, references = []) {
     const optionName = path.at(-1);
     check.assert(v.string(), optionName, 'Path must end at an option name! ❌');
-    const descended = resolveItems(model, instance, path.slice(0, -1), refs);
+    const descended = resolveItems(model, instance, path.slice(0, -1), references);
     if (descended == null) {
         return null;
     }
@@ -42,13 +41,13 @@ export function resolvePath(model, instance, path, refs = []) {
     const merged = modelsMerge(scopeModel);
     const option = merged.options.find((entry) => entry.name === optionName);
     check.truthy(option, `Path target '${optionName}' is not an option! ❌`);
-    const payload = resolveOption(option, scopeModel, scopeInstance, refs);
+    const payload = resolveOption(option, scopeModel, scopeInstance, references);
     if (payload == null) {
         return null;
     }
     return { name: optionName, payload, value: scopeInstance[optionName] };
 }
-export function resolveItems(model, instance, pairs, refs = []) {
+export function resolveItems(model, instance, pairs, references = []) {
     check.assert(BuilderInstanceSchema, instance);
     if (pairs.length === 0) {
         return [model, instance];
@@ -59,7 +58,7 @@ export function resolveItems(model, instance, pairs, refs = []) {
     const merged = modelsMerge(model);
     const collection = merged.collections.find((entry) => entry.name === name);
     check.truthy(collection, `Path segment '${name}' is not a collection! ❌`);
-    const resolved = resolveCollection(collection, model, instance, refs);
+    const resolved = resolveCollection(collection, model, instance, references);
     if (resolved == null) {
         return null;
     }
@@ -69,17 +68,17 @@ export function resolveItems(model, instance, pairs, refs = []) {
     if (item == null) {
         return null;
     }
-    return resolveItems(resolved.model, item, rest, refs);
+    return resolveItems(resolved.model, item, rest, references);
 }
-function resolveEntryInstance(entry, schema, model, instance, refs) {
-    const payload = resolveRef(entry.payload, refs);
+function resolveEntryInstance(entry, schema, model, instance, references) {
+    const payload = resolveReference(entry.payload, references);
     if (check.is(schema, payload)) {
         return payload;
     }
     check.assert(BuilderWhenSerialisedSchema, payload);
     check.assert(BuilderPathsSchema, entry.paths);
     const config = payload;
-    if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, refs)?.value))) {
+    if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, references)?.value))) {
         return null;
     }
     switch (config.type) {
@@ -88,11 +87,11 @@ function resolveEntryInstance(entry, schema, model, instance, refs) {
         }
         case 'match': {
             const selectMap = config.selectMap;
-            const matched = resolvePath(model, instance, config.matchPath, refs);
+            const matched = resolvePath(model, instance, config.matchPath, references);
             return selectMap[`${matched?.value}`] ?? null;
         }
         case 'unless': {
-            const value = resolvePath(model, instance, config.unlessPath, refs)?.value;
+            const value = resolvePath(model, instance, config.unlessPath, references)?.value;
             if (!value) {
                 return null;
             }
@@ -104,22 +103,6 @@ function resolveEntryInstance(entry, schema, model, instance, refs) {
         }
     }
 }
-function resolveEntryExhaustive(entry, schema, refs) {
-    const payload = resolveRef(entry.payload, refs);
-    if (check.is(schema, payload)) {
-        return [payload];
-    }
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return [];
-    }
-    const when = payload;
-    switch (when.type) {
-        case 'enable':
-        case 'unless': {
-            return [when.payload];
-        }
-        case 'match': {
-            return Object.values(when.selectMap).filter((branch) => branch != null);
-        }
-    }
+function resolveEntryExhaustive(entry, schema, references) {
+    return whenBranches(resolveReference(entry.payload, references), schema);
 }

package/dist/mappers/variants/option-graph.d.ts

@@ -1,6 +1,5 @@
-import type { BuilderModelValidated, BuilderOptionValidated, BuilderWhen } from '../../entities/index';
+import type { BuilderModelValidated, BuilderOptionValidated, BuilderPaths } from '../../entities/index';
 import type { BuilderInstances } from '../../instance';
-import type { BuilderPaths } from '../../paths';
 export type GraphKeys = ReadonlySet<string>;
 export type GraphPath = {
     name: string;
@@ -9,7 +8,7 @@ export type GraphPath = {
 };
 export type GraphPaths = ReadonlyArray<GraphPath>;
 export declare function crossProduct(left: BuilderInstances, right: BuilderInstances): BuilderInstances;
-export declare function dependencyKeys(payload: unknown | BuilderWhen, paths?: BuilderPaths): ReadonlyArray<string>;
+export declare function dependencyKeys(payload: unknown, paths?: BuilderPaths): ReadonlyArray<string>;
 export declare class BuilderOptionGraph {
     #private;
     readonly paths: GraphPaths;

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

@@ -1,6 +1,5 @@
-import { check } from '../../check.js';
-import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
-import { BuilderPathSchema } from '../../paths.js';
+import { BuilderPathSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
+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 })));

package/dist/mappers/variants/variants.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderCollectionValidated, BuilderComponentValidated, BuilderModelValidated, BuilderValidated } from '../../entities/index';
-import type { BuilderComponentVariants, BuilderInstances } from '../../instance';
+import type { BuilderVariants, BuilderInstances } from '../../instance';
 import { BuilderOptionGraph } from './option-graph.js';
-export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderVariants;
 export declare function optionGraph(model: BuilderModelValidated): BuilderOptionGraph;
 export declare function variantsFor(entity: BuilderComponentValidated | BuilderCollectionValidated, options: BuilderOptionGraph): BuilderInstances;

package/dist/mappers/variants/variants.js

@@ -1,5 +1,5 @@
-import { check } from '../../check.js';
 import { BuilderModelSerialisedSchema, BuilderSerialisedSchema } from '../../entities/index.js';
+import { check } from '../../errors/index.js';
 import { resolveCollection } from '../resolve.js';
 import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
 export function createVariants(entity) {

package/dist/private.d.ts

@@ -1,4 +1,3 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
 export { BuilderEnvironmentSchema } from './environment.js';
 export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
-export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/private.js

@@ -1,4 +1,3 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
 export { BuilderEnvironmentSchema } from './environment.js';
 export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
-export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/references.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { check } from './check.js';
+import { check } from './errors/index.js';
 export class BuilderParameter {
     id;
     name;

package/dist/validate/brand.js

@@ -1,5 +1,4 @@
-import { BuilderException } from '../exception.js';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderException, BuilderValidateErrors } from '../errors/index.js';
 const VALIDATED_ENTITIES = new WeakSet();
 export function validate(value) {
     VALIDATED_ENTITIES.add(value);

package/dist/validate/builder.d.ts

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

package/dist/validate/builder.js

@@ -1,7 +1,6 @@
-import { check } from '../check.js';
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
 import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
@@ -9,7 +8,7 @@ import { checkUIExpectations, validateUIStructure } from './ui.js';
 const EMPTY_BUILDER = validate(serialise.builder(builder()));
 export function validateBuilder(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        errors.invalidInput('builder');
+        errors.invalidEntity('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';
+import type { BuilderValidateErrors } from '../errors/index';
 export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/index.d.ts

@@ -1,10 +1,13 @@
+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 { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidPricingReason, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingRate, 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, BuilderVariantsValidationOptions } from './variants';
+export type { BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './variants';
+export { createEntityValidator } from '../entities/index.js';
 export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';

package/dist/validate/index.js

@@ -1,3 +1,4 @@
+export { createEntityValidator } from '../entities/index.js';
 export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';

package/dist/validate/instance.d.ts

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

package/dist/validate/instance.js

@@ -1,9 +1,8 @@
-import { check } from '../check.js';
 import { optionValueSchema } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 export function validateInstance(model, instance, errors = new BuilderValidateErrors()) {
     errors.scope('instance', () => {
         checkInstance(model, instance);

package/dist/validate/model.d.ts

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

package/dist/validate/model.js

@@ -1,15 +1,14 @@
-import { check } from '../check.js';
-import { BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
+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 { isParamable } from '../references.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
-import { resolveCollections } from '../mappers/index.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()) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        errors.invalidInput('model');
+        errors.invalidEntity('model');
         return [EMPTY_MODEL, errors.errors];
     }
     const resolve = resolver(errors, references);
@@ -41,9 +40,32 @@ export function validateModelStructure(input, resolve, errors) {
     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 = walkEntries(modelInput.options, 'option');
-    const components = walkEntries(modelInput.components, 'component');
-    const collections = walkCollections();
+    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,
@@ -51,34 +73,17 @@ export function validateModelStructure(input, resolve, errors) {
         components,
         collections
     };
-    function walkEntries(entries, entryKind) {
+    function walkEntries(entries, validateBranches) {
         const seen = new Set();
         const items = [];
-        errors.scope(`${entryKind}s`, () => {
-            entries.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
-                    const resolved = resolveEntry(entry, seen);
-                    if (resolved != null) {
-                        items.push(resolved);
-                    }
-                });
-            });
-        });
-        return items;
-    }
-    function walkCollections() {
-        const seen = new Set();
-        const items = [];
-        errors.scope('collections', () => {
-            modelInput.collections.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
-                    const resolved = resolveEntry(entry, seen);
-                    if (resolved == null) {
-                        return;
-                    }
-                    checkCollectionBounds(resolved);
-                    items.push(resolved);
-                });
+        entries.forEach((entry, entryIndex) => {
+            errors.scope(entryIndex, () => {
+                const resolved = resolveEntry(entry, seen);
+                if (resolved == null) {
+                    return;
+                }
+                validateBranches(resolved);
+                items.push(resolved);
             });
         });
         return items;
@@ -135,14 +140,4 @@ export function validateModelStructure(input, resolve, errors) {
             });
         }
     }
-    function checkCollectionBounds(collection) {
-        resolveCollections(collection).forEach(({ min, max }) => {
-            if (typeof min !== 'number' || typeof max !== 'number') {
-                return;
-            }
-            if (min < 0 || max <= 0 || max < min) {
-                errors.invalidCollectionBounds(collection.name, min, max);
-            }
-        });
-    }
 }

package/dist/validate/paths.d.ts

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

package/dist/validate/paths.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
 import { BuilderModelSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 const NumberSchema = v.number();
 const StringSchema = v.string();

package/dist/validate/pricing.d.ts

@@ -1,8 +1,7 @@
-import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderReferences, ValidationResult } from '../entities/index';
 import type { BuilderResolve } from './resolve';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderPricingValidationResult = ValidationResult<BuilderPricingValidated>;
-export declare function validatePricing(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
+export declare function validatePricing(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
 export declare function validatePricingStructure(input: BuilderPricingSerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderPricingSerialised;
 export declare function checkPricingExpectations(model: BuilderModelSerialised, pricing: BuilderPricingSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/pricing.js

@@ -1,14 +1,13 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { resolver } from './resolve.js';
 const EMPTY_PRICING = validate(serialise.pricing(pricing()));
 const NumberSchema = v.number();
 export function validatePricing(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
-        errors.invalidInput('pricing');
+        errors.invalidEntity('pricing');
         return [EMPTY_PRICING, errors.errors];
     }
     const resolve = resolver(errors, references);

package/dist/validate/resolve.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderBindings, BuilderRefEntities } from '../entities/index';
-import type { BuilderValidateErrors } from './errors';
+import type { BuilderBindings, BuilderReferences } from '../entities/index';
+import type { BuilderValidateErrors } from '../errors/index';
 export type BuilderResolve = (value: unknown) => unknown;
-export declare function resolver(errors: BuilderValidateErrors, references?: BuilderRefEntities, bindings?: BuilderBindings): BuilderResolve;
+export declare function resolver(errors: BuilderValidateErrors, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -1,5 +1,5 @@
-import { check } from '../check.js';
 import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
 export function resolver(errors, references = [], bindings = {}) {

package/dist/validate/ui.d.ts

@@ -1,8 +1,7 @@
-import type { BuilderModelSerialised, BuilderRefEntities, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
+import type { BuilderModelSerialised, BuilderReferences, BuilderUISerialised, BuilderUIValidated, ValidationResult } from '../entities/index';
 import type { BuilderResolve } from './resolve';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
-export declare function validateUI(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderUIValidationResult;
+export declare function validateUI(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderUIValidationResult;
 export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderUIValidated;
 export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, errors: BuilderValidateErrors): void;

package/dist/validate/ui.js

@@ -1,14 +1,13 @@
-import { check } from '../check.js';
-import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis } from '../entities/index.js';
-import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
+import { validate } from './brand.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
-        errors.invalidInput('ui');
+        errors.invalidEntity('ui');
         return [validate(serialise.ui(uis())), errors.errors];
     }
     const resolve = resolver(errors, references);
@@ -40,6 +39,15 @@ export function validateUIStructure(ui, resolve, errors) {
         }));
     }
     function walkUIItem(item) {
+        if (item.type === 'page') {
+            validateUIPage(item, [], errors);
+        }
+        else if (item.type === 'pages') {
+            validateUIPages(item, [], errors);
+        }
+        else if (item.type === 'describe') {
+            validateUIDescribe(item, [], errors);
+        }
         const label = errors.scope('label', () => resolve(item.label) ?? item.label);
         if (item.type === 'pages') {
             const innerItems = errors.scope('items', () => {
@@ -65,6 +73,7 @@ export function validateUIStructure(ui, resolve, errors) {
         }));
     }
     function walkInput(value) {
+        validateUIInput(value, [], errors);
         const path = errors.scope('path', () => resolve(value.path) ?? value.path);
         const displayName = value.displayName &&
             errors.scope('displayName', () => resolve(value.displayName) ?? value.displayName);

package/dist/validate/variants.d.ts

@@ -1,8 +1,7 @@
-import type { BuilderComponentVariantsValidated, BuilderModelValidated } from '../entities/index';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import type { BuilderModelValidated, BuilderVariantsValidated, ValidationResult } from '../entities/index';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderVariantsValidationOptions = {
     readonly partial?: boolean;
 };
-export type BuilderComponentVariantsValidationResult = ValidationResult<BuilderComponentVariantsValidated>;
-export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderComponentVariantsValidationResult;
+export type BuilderVariantsValidationResult = ValidationResult<BuilderVariantsValidated>;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderVariantsValidationResult;

package/dist/validate/variants.js

@@ -1,12 +1,11 @@
-import { check } from '../check.js';
-import { BuilderComponentDetailsSerialisedSchema, detailValueSchema } from '../entities/index.js';
-import { BuilderComponentVariantsSchema } from '../instance.js';
+import { BuilderComponentConfigSerialisedSchema, detailValueSchema } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderVariantsSchema } from '../instance.js';
 import { createVariants } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 export function validateVariants(model, input, options = {}, errors = new BuilderValidateErrors()) {
-    if (!check.is(BuilderComponentVariantsSchema, input)) {
-        errors.invalidInput('variants');
+    if (!check.is(BuilderVariantsSchema, input)) {
+        errors.invalidVariants();
         return [validate({}), errors.errors];
     }
     const variants = input;
@@ -99,7 +98,7 @@ export function validateVariants(model, input, options = {}, errors = new Builde
 }
 function variantDetails(component, variantInstance) {
     const { payload } = component;
-    if (check.is(BuilderComponentDetailsSerialisedSchema, payload)) {
+    if (check.is(BuilderComponentConfigSerialisedSchema, payload)) {
         return payload;
     }
     if (payload.type === 'match') {