@builder-builder/builder 0.0.26 → 0.0.28

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

package/dist/validate/model.js

@@ -1,40 +1,41 @@
 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 { BuilderIssuesScope, check } from '../errors/index.js';
+import { dependencies } from '../mappers/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 BuilderErrorsScope(input)) {
+export function validateModel(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        errors.entityInvalid('model');
-        return [EMPTY_MODEL, errors.errors];
+        issues.entityInvalid('model');
+        return [EMPTY_MODEL, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references);
-    const structure = validateModelStructure(input, resolve, errors);
+    const resolve = resolver(issues, references);
+    const structure = validateModelStructure(input, resolve, issues);
     const merged = modelsMerge(structure);
     const data = validate(merged);
-    checkModelExpectations(data, structure, errors);
-    return [data, errors.errors];
+    checkModelExpectations(data, structure, issues);
+    return [data, issues.errors, issues.warnings];
 }
-export function checkModelExpectations(mergedModel, rootModel, errors) {
+export function checkModelExpectations(mergedModel, rootModel, issues) {
     recurse(rootModel);
     function recurse(node) {
-        errors.scope('expectations', () => {
-            checkExpectations(mergedModel, node.expectations, errors);
+        issues.scope('expectations', () => {
+            checkExpectations(mergedModel, node.expectations, issues);
         });
-        errors.scope('models', () => {
+        issues.scope('models', () => {
             node.models.forEach((nested, nestedIndex) => {
-                errors.scope(nestedIndex, () => {
+                issues.scope(nestedIndex, () => {
                     recurse(nested);
                 });
             });
         });
     }
 }
-export function validateModelStructure(input, resolve, errors) {
+export function validateModelStructure(input, resolve, issues) {
     const seenGlobal = {
         option: new Set(),
         component: new Set(),
@@ -47,41 +48,45 @@ export function validateModelStructure(input, resolve, errors) {
             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) => {
+        const childModels = issues.scope('models', () => modelInput.models.flatMap((part, partIndex) => issues.scope(partIndex, () => [walkStructure(part)])));
+        const options = issues.scope('options', () => walkEntries(modelInput.options, 'option', (resolved) => {
             whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
                 if (config.type === 'select') {
-                    validateSelect(config, [], errors);
+                    validateSelect(config, [], issues);
                 }
                 else if (config.type === 'toggle') {
-                    validateToggle(config, [], errors);
+                    validateToggle(config, [], issues);
                 }
             });
         }));
-        const components = errors.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
+        const components = issues.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
             whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                validateComponentConfig(config, [], errors);
+                validateComponentConfig(config, [], issues);
             });
         }));
-        const collections = errors.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
+        const collections = issues.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
             whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                validateCollectionConfig(config, [], errors);
+                validateCollectionConfig(config, [], issues);
             });
         }));
-        return {
+        const validatedModel = {
             ...modelInput,
             models: childModels,
             options,
             components,
             collections
         };
+        const ordered = new Set(dependencies(validatedModel));
+        if ([...options, ...collections, ...components].some((entry) => !ordered.has(entry.name))) {
+            issues.modelCircularDependency();
+        }
+        return validatedModel;
         function payloadSchemaFor(kind) {
             if (kind === 'option') {
                 return BuilderOptionConfigSerialisedSchema;
@@ -95,7 +100,7 @@ export function validateModelStructure(input, resolve, errors) {
             const seenLocal = new Set();
             const items = [];
             entries.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
+                issues.scope(entryIndex, () => {
                     const resolved = resolveEntry(entry, seenLocal, kind);
                     if (resolved == null) {
                         return;
@@ -109,33 +114,33 @@ export function validateModelStructure(input, resolve, errors) {
         function resolveEntry(entry, seenLocal, kind) {
             let paths = entry.paths;
             if (entry.paths != null) {
-                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
+                const resolvedPaths = issues.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 payload = issues.scope('payload', () => resolve(entry.payload, payloadSchema));
             const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
             if (seenLocal.has(resolvedEntry.name)) {
                 if (kind === 'option') {
-                    errors.modelDuplicateOption();
+                    issues.modelDuplicateOption();
                 }
                 else if (kind === 'component') {
-                    errors.modelDuplicateComponent();
+                    issues.modelDuplicateComponent();
                 }
                 else {
-                    errors.modelDuplicateCollection();
+                    issues.modelDuplicateCollection();
                 }
                 return null;
             }
             if (seenGlobal[kind].has(resolvedEntry.name)) {
                 if (kind === 'option') {
-                    errors.modelOverriddenOption();
+                    issues.modelOverriddenOption();
                 }
                 else if (kind === 'component') {
-                    errors.modelOverriddenComponent();
+                    issues.modelOverriddenComponent();
                 }
                 else {
-                    errors.modelOverriddenCollection();
+                    issues.modelOverriddenCollection();
                 }
             }
             seenLocal.add(resolvedEntry.name);
@@ -144,15 +149,12 @@ export function validateModelStructure(input, resolve, errors) {
             return resolvedEntry;
         }
         function checkPaths(entry) {
-            if (skipPathValidation) {
-                return;
-            }
             const { paths, payload } = entry;
             if (Array.isArray(paths)) {
-                errors.scope('paths', () => {
+                issues.scope('paths', () => {
                     paths.forEach((path, pathIndex) => {
-                        errors.scope(pathIndex, () => {
-                            checkPath(modelInput, path, errors);
+                        issues.scope(pathIndex, () => {
+                            checkPath(modelInput, path, issues);
                         });
                     });
                 });
@@ -161,10 +163,17 @@ export function validateModelStructure(input, resolve, errors) {
                 return;
             }
             if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
-                errors.scope('payload', () => errors.scope('matchPath', () => checkPath(modelInput, payload.matchPath, errors)));
+                issues.scope('payload', () => issues.scope('matchPath', () => checkPath(modelInput, payload.matchPath, issues)));
             }
-            if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
-                errors.scope('payload', () => errors.scope('unlessPath', () => checkPath(modelInput, payload.unlessPath, errors)));
+            if (payload.type === 'unless') {
+                if (payload.disabledValues.length === 0) {
+                    issues.scope('payload', () => issues.scope('disabledValues', () => {
+                        issues.entityEmptyDisabledValues();
+                    }));
+                }
+                if (Array.isArray(payload.unlessPath)) {
+                    issues.scope('payload', () => issues.scope('unlessPath', () => checkPath(modelInput, payload.unlessPath, issues)));
+                }
             }
         }
     }

package/dist/validate/paths.d.ts

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

package/dist/validate/paths.js

@@ -2,19 +2,24 @@ import { BuilderModelSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 import { NameSchema, NumberSchema } from '../primitive.js';
-export function checkPath(model, path, errors) {
+export function checkPath(model, path, issues) {
     if (path.length === 0) {
-        errors.pathEmpty();
+        issues.pathEmpty();
+        return;
+    }
+    const [firstSegment] = path;
+    if (check.is(NameSchema, firstSegment) &&
+        model.expectations.some((expectation) => expectation.name === firstSegment)) {
         return;
     }
     const lastIndex = path.length - 1;
-    const models = walkPath([model], path.slice(0, -1), 0, errors);
+    const models = walkPath([model], path.slice(0, -1), 0, issues);
     if (models == null) {
         return;
     }
     const optionName = path.at(-1);
     if (!check.is(NameSchema, optionName)) {
-        errors.scope(lastIndex, () => errors.pathInvalidSegment());
+        issues.scope(lastIndex, () => issues.pathInvalidSegment());
         return;
     }
     if (models.some((model) => model.options.some((option) => option.name === optionName))) {
@@ -22,27 +27,27 @@ export function checkPath(model, path, errors) {
     }
     const isCollection = models.some((model) => model.collections.some((entry) => entry.name === optionName));
     if (isCollection) {
-        errors.scope(lastIndex, () => errors.pathTargetIsCollection());
+        issues.scope(lastIndex, () => issues.pathTargetIsCollection());
         return;
     }
     const isComponent = models.some((model) => model.components.some((entry) => entry.name === optionName));
     if (isComponent) {
-        errors.scope(lastIndex, () => errors.pathTargetIsComponent());
+        issues.scope(lastIndex, () => issues.pathTargetIsComponent());
         return;
     }
-    errors.scope(lastIndex, () => errors.pathMissingOption());
+    issues.scope(lastIndex, () => issues.pathMissingOption());
 }
-function walkPath(models, remaining, offset, errors) {
+function walkPath(models, remaining, offset, issues) {
     if (remaining.length === 0) {
         return models;
     }
     const [collectionName, index, ...rest] = remaining;
     if (!check.is(NameSchema, collectionName)) {
-        errors.scope(offset, () => errors.pathInvalidSegment());
+        issues.scope(offset, () => issues.pathInvalidSegment());
         return null;
     }
     if (!check.is(NumberSchema, index)) {
-        errors.scope(offset + 1, () => errors.pathInvalidSegment());
+        issues.scope(offset + 1, () => issues.pathInvalidSegment());
         return null;
     }
     const collectionConfigs = models.flatMap((model) => {
@@ -50,7 +55,7 @@ function walkPath(models, remaining, offset, errors) {
         return collection == null ? [] : resolveCollections(collection);
     });
     if (collectionConfigs.length === 0) {
-        errors.scope(offset, () => errors.pathMissingCollection());
+        issues.scope(offset, () => issues.pathMissingCollection());
         return null;
     }
     const indexableConfigs = collectionConfigs.filter(({ max }) => !check.is(NumberSchema, max) || index < max);
@@ -61,13 +66,13 @@ function walkPath(models, remaining, offset, errors) {
             }
             return max > highest ? max : highest;
         }, 0);
-        errors.scope(offset + 1, () => errors.pathInvalidIndex(max));
+        issues.scope(offset + 1, () => issues.pathInvalidIndex(max));
         return null;
     }
     const next = indexableConfigs.flatMap((collectionConfig) => check.is(BuilderModelSerialisedSchema, collectionConfig.model) ? [collectionConfig.model] : []);
     if (next.length === 0) {
-        errors.scope(offset, () => errors.pathMissingCollection());
+        issues.scope(offset, () => issues.pathMissingCollection());
         return null;
     }
-    return walkPath(next, rest, offset + 2, errors);
+    return walkPath(next, rest, offset + 2, issues);
 }

package/dist/validate/pricing.d.ts

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

package/dist/validate/pricing.js

@@ -1,25 +1,25 @@
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
 import { NumberSchema } from '../primitive.js';
 import { validate } from './brand.js';
 import { resolver } from './resolve.js';
 const EMPTY_PRICING = validate(serialise.pricing(pricing()));
-export function validatePricing(input, references = [], errors = new BuilderErrorsScope(input)) {
+export function validatePricing(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
-        errors.entityInvalid('pricing');
-        return [EMPTY_PRICING, errors.errors];
+        issues.entityInvalid('pricing');
+        return [EMPTY_PRICING, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references);
-    const structure = validatePricingStructure(input, resolve, errors);
-    return [validate(structure), errors.errors];
+    const resolve = resolver(issues, references);
+    const structure = validatePricingStructure(input, resolve, issues);
+    return [validate(structure), issues.errors, issues.warnings];
 }
-export function validatePricingStructure(input, resolve, errors) {
-    const rates = errors.scope('rates', () => input.rates.flatMap((entry, index) => {
+export function validatePricingStructure(input, resolve, issues) {
+    const rates = issues.scope('rates', () => input.rates.flatMap((entry, index) => {
         const resolved = resolve(entry, BuilderRatesSchema);
         if (resolved != null) {
             return [resolved];
         }
-        errors.scope(index, () => errors.pricingInvalidRateValue());
+        issues.scope(index, () => issues.pricingInvalidRateValue());
         return [];
     }));
     const formula = input.formula == null ? null : resolveExpression(input.formula);
@@ -30,7 +30,7 @@ export function validatePricingStructure(input, resolve, errors) {
     function resolveExpression(input) {
         const resolved = resolve(input, BuilderPricingExpressionSchema);
         if (resolved == null) {
-            errors.pricingMalformedExpression();
+            issues.pricingMalformedExpression();
             return null;
         }
         if (check.is(NumberSchema, resolved)) {
@@ -40,11 +40,11 @@ export function validatePricingStructure(input, resolve, errors) {
             return resolved;
         }
         if (resolved.kind === 'variants') {
-            const inner = errors.scope('expression', () => resolveExpression(resolved.expression));
+            const inner = issues.scope('expression', () => resolveExpression(resolved.expression));
             return { ...resolved, expression: inner ?? resolved.expression };
         }
-        const left = errors.scope('left', () => resolveExpression(resolved.left));
-        const right = errors.scope('right', () => resolveExpression(resolved.right));
+        const left = issues.scope('left', () => resolveExpression(resolved.left));
+        const right = issues.scope('right', () => resolveExpression(resolved.right));
         return { ...resolved, left: left ?? resolved.left, right: right ?? resolved.right };
     }
     function walkExpression(expression, insideVariants) {
@@ -54,33 +54,33 @@ export function validatePricingStructure(input, resolve, errors) {
         switch (expression.kind) {
             case 'variantPrice':
                 if (!insideVariants) {
-                    errors.pricingInvalidScope();
+                    issues.pricingInvalidScope();
                 }
                 return;
             case 'lookup':
-                errors.scope('lookup', () => {
+                issues.scope('lookup', () => {
                     if (rates.length === 0) {
-                        errors.pricingEmptyRates();
+                        issues.pricingEmptyRates();
                     }
                     else {
                         const exists = rates.some((entry) => entry[expression.rate] != null);
                         if (!exists) {
-                            errors.pricingMissingRate();
+                            issues.pricingMissingRate();
                         }
                     }
                     if (!insideVariants) {
-                        errors.pricingInvalidScope();
+                        issues.pricingInvalidScope();
                     }
                 });
                 return;
             case 'variants':
-                errors.scope('variants', () => {
+                issues.scope('variants', () => {
                     if (insideVariants) {
-                        errors.pricingNestedVariants();
+                        issues.pricingNestedVariants();
                     }
                     const inner = expression.expression;
                     check.assert(BuilderPricingExpressionSchema, inner);
-                    errors.scope('expression', () => walkExpression(inner, true));
+                    issues.scope('expression', () => walkExpression(inner, true));
                 });
                 return;
             case 'add':
@@ -91,16 +91,16 @@ export function validatePricingStructure(input, resolve, errors) {
                 check.assert(BuilderPricingExpressionSchema, left);
                 check.assert(BuilderPricingExpressionSchema, right);
                 if (expression.kind === 'div' && check.is(NumberSchema, right) && right === 0) {
-                    errors.pricingDivideByZero();
+                    issues.pricingDivideByZero();
                 }
-                errors.scope('left', () => walkExpression(left, insideVariants));
-                errors.scope('right', () => walkExpression(right, insideVariants));
+                issues.scope('left', () => walkExpression(left, insideVariants));
+                issues.scope('right', () => walkExpression(right, insideVariants));
                 return;
             }
         }
     }
 }
-export function checkPricingExpectations(model, pricing, errors) {
+export function checkPricingExpectations(model, pricing, issues) {
     if (pricing.formula == null) {
         return;
     }
@@ -115,21 +115,21 @@ export function checkPricingExpectations(model, pricing, errors) {
         }
         switch (expression.kind) {
             case 'lookup':
-                errors.scope('lookup', () => {
+                issues.scope('lookup', () => {
                     if (expression.key.kind === 'option' && !optionNames.has(expression.key.name)) {
-                        errors.pricingMissingOption();
+                        issues.pricingMissingOption();
                     }
                 });
                 return;
             case 'variants':
-                errors.scope('variants', () => errors.scope('expression', () => walkExpression(expression.expression)));
+                issues.scope('variants', () => issues.scope('expression', () => walkExpression(expression.expression)));
                 return;
             case 'add':
             case 'sub':
             case 'mul':
             case 'div':
-                errors.scope('left', () => walkExpression(expression.left));
-                errors.scope('right', () => walkExpression(expression.right));
+                issues.scope('left', () => walkExpression(expression.left));
+                issues.scope('right', () => walkExpression(expression.right));
                 return;
             default:
                 return;

package/dist/validate/resolve.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
-import type { BuilderErrorsScope } from '../errors/index';
+import type { BuilderIssuesScope } from '../errors/index';
 import * as v from 'valibot';
 export type BuilderResolve = <S extends v.GenericSchema = v.GenericSchema<unknown>>(value: unknown, schema?: S) => v.InferOutput<S> | null;
-export declare function resolver(errors: BuilderErrorsScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;
+export declare function resolver(issues: BuilderIssuesScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -4,16 +4,16 @@ import { check } from '../errors/index.js';
 import { NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
-export function resolver(errors, references = [], bindings = {}) {
+export function resolver(issues, references = [], bindings = {}) {
     const resolving = new Set();
     function resolve(value, schema = v.unknown()) {
-        const errorsBefore = errors.errors.length;
+        const errorsBefore = issues.errors.length;
         const resolved = dispatch(value, schema);
         if (check.is(schema, resolved)) {
             return resolved;
         }
-        if (errors.errors.length === errorsBefore) {
-            errors.referenceInvalid();
+        if (issues.errors.length === errorsBefore) {
+            issues.referenceInvalid();
         }
         return null;
     }
@@ -34,12 +34,12 @@ export function resolver(errors, references = [], bindings = {}) {
     }
     function resolveReference(reference, schema) {
         if (resolving.has(reference.id)) {
-            errors.referenceCircular();
+            issues.referenceCircular();
             return reference;
         }
         const found = references.find((entry) => entry.id === reference.id);
         if (found == null) {
-            errors.referenceMissing();
+            issues.referenceMissing();
             return reference;
         }
         resolving.add(reference.id);
@@ -52,7 +52,7 @@ export function resolver(errors, references = [], bindings = {}) {
     }
     function resolveParameter(parameter, schema) {
         if (!(parameter.name in bindings)) {
-            errors.referenceUnboundParameter();
+            issues.referenceUnboundParameter();
             return null;
         }
         const binding = bindings[parameter.name];
@@ -63,43 +63,43 @@ export function resolver(errors, references = [], bindings = {}) {
     }
     function resolveWhen(when, payloadSchema) {
         if (when.type === 'enable') {
-            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
+            const payload = issues.scope('payload', () => resolve(when.payload, payloadSchema));
             return { ...when, payload: payload ?? when.payload };
         }
         if (when.type === 'unless') {
-            const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath, BuilderPathSchema));
-            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
+            const unlessPath = issues.scope('unlessPath', () => resolve(when.unlessPath, BuilderPathSchema));
+            const payload = issues.scope('payload', () => resolve(when.payload, payloadSchema));
             return {
                 ...when,
                 unlessPath: unlessPath ?? when.unlessPath,
                 payload: payload ?? when.payload
             };
         }
-        const matchPath = errors.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
+        const matchPath = issues.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
         const selectMapSchema = v.record(StringSchema, v.nullable(v.unknown()));
-        const map = errors.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
+        const map = issues.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
         if (map == null) {
             return { ...when, matchPath: matchPath ?? when.matchPath };
         }
-        const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
+        const selectMap = issues.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
             if (entryValue == null) {
                 return { ...values, [key]: null };
             }
-            const resolved = errors.scope(key, () => resolve(entryValue, payloadSchema));
+            const resolved = issues.scope(key, () => resolve(entryValue, payloadSchema));
             return { ...values, [key]: resolved ?? entryValue };
         }, {}));
         return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
     }
     function resolveCollectionConfig(config) {
-        const model = errors.scope('model', () => {
+        const model = issues.scope('model', () => {
             const resolved = resolve(config.model, BuilderModelSerialisedSchema);
             if (resolved == null) {
                 return null;
             }
-            return validateModelStructure(resolved, resolve, errors);
+            return validateModelStructure(resolved, resolve, issues);
         });
-        const min = errors.scope('min', () => resolve(config.min, NumberSchema));
-        const max = errors.scope('max', () => resolve(config.max, NumberSchema));
+        const min = issues.scope('min', () => resolve(config.min, NumberSchema));
+        const max = issues.scope('max', () => resolve(config.max, NumberSchema));
         return {
             ...config,
             model: model ?? config.model,

package/dist/validate/ui.d.ts

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