@builder-builder/builder 0.0.12 → 0.0.14

package/dist/mappers/render/render.js

@@ -1,9 +1,10 @@
+import { BuilderRenderMetadataSchema } from './pages.js';
 import * as v from 'valibot';
 import { check } from '../../check.js';
-import { modelsMerge } from '../../entities/model/index.js';
 import { BuilderInstancesSchema } from '../../instance.js';
-import { readPath } from '../../paths.js';
-import { resolveCollection, resolveOption, resolveRef } from '../resolve.js';
+import { BuilderPrimitiveSchema } from '../../primitive.js';
+import { createInstance } from '../instance.js';
+import { resolveCollection, resolvePath, resolveRef } from '../resolve.js';
 import { ordinal } from './ordinal.js';
 export function render(builder, instance, refs = []) {
     const layout = [];
@@ -30,26 +31,30 @@ export function render(builder, instance, refs = []) {
             }
             const itemInstances = currentInstance[item.name];
             check.assert(BuilderInstancesSchema, itemInstances, 'Collection field is not an array! ❌');
-            const mergedItemModel = modelsMerge(collection.model);
+            const mergedItemModel = collection.model;
             itemInstances.forEach((itemInstance, index) => {
                 walkItems(item.items, mergedItemModel, [...collectionPath, item.name, index], [...labelContext, `${ordinal(index)} ${composeLabel(item.label)}`], itemInstance);
             });
         });
     }
     function emitPage(page, model, collectionPath, labelContext, currentInstance) {
-        const options = page.paths.flatMap((path) => {
-            const found = findOption(model, currentInstance, path);
+        const options = page.inputs.flatMap((input) => {
+            const { path } = input;
+            const found = resolvePath(model, currentInstance, path, refs);
             if (found == null) {
                 return [];
             }
             const fullPath = [...collectionPath, ...path];
-            const [name, option] = found;
+            check.assert(BuilderPrimitiveSchema, found.value);
             return [
                 {
-                    name,
-                    option,
-                    value: readPath(currentInstance, path),
-                    update: (updateInstance, updateValue) => setPath(updateInstance, fullPath, updateValue)
+                    name: found.name,
+                    option: found.payload,
+                    value: found.value,
+                    update: (updateInstance, updateValue) => createInstance(builder, setPath(updateInstance, fullPath, updateValue), refs),
+                    displayName: input.displayName && composeString(input.displayName, 'displayName'),
+                    kind: input.kind && composeString(input.kind, 'kind'),
+                    metadata: input.metadata && composeMetadata(input.metadata)
                 }
             ];
         });
@@ -60,16 +65,14 @@ export function render(builder, instance, refs = []) {
     }
     function emitDescribe(describe, model, labelContext, currentInstance) {
         const composedLabel = composeLabel(describe.label, labelContext);
-        const values = describe.paths.flatMap((path) => {
-            const found = findOption(model, currentInstance, path);
-            if (found == null) {
-                return [];
-            }
-            const value = readPath(currentInstance, path);
-            if (value == null) {
+        const values = describe.inputs.flatMap((input) => {
+            const { path } = input;
+            const found = resolvePath(model, currentInstance, path, refs);
+            if (found?.value == null) {
                 return [];
             }
-            return [value];
+            check.assert(BuilderPrimitiveSchema, found.value);
+            return [found.value];
         });
         if (values.length === 0) {
             return;
@@ -87,45 +90,19 @@ export function render(builder, instance, refs = []) {
         }
         return `${labelContext.join(', ')}, ${resolved}`;
     }
-    function findOption(model, instance, path) {
-        const optionName = path.at(-1);
-        check.assert(v.string(), optionName);
-        const collectionPairs = path.slice(0, -1);
-        const descended = descendPairs(model, instance, collectionPairs);
-        if (!descended) {
-            return null;
-        }
-        const [scopeModel, scopeInstance] = descended;
-        const entry = scopeModel.options.find((option) => option.name === optionName);
-        if (entry == null) {
-            return null;
-        }
-        const optionValues = resolveOption(entry, scopeInstance, refs);
-        if (optionValues == null) {
-            return null;
-        }
-        return [entry.name, optionValues];
+    function composeString(value, fieldLabel) {
+        const resolved = resolveRef(value, refs);
+        check.assert(v.string(), resolved, `Input ${fieldLabel} did not resolve to a string! ❌`);
+        return resolved;
     }
-    function descendPairs(model, instance, remaining) {
-        if (remaining.length === 0) {
-            return [model, instance];
-        }
-        const [collectionName, instanceIndex, ...rest] = remaining;
-        check.assert(v.string(), collectionName);
-        check.assert(v.number(), instanceIndex);
-        const collection = findCollection(model, instance, collectionName);
-        if (!collection) {
-            return null;
-        }
-        const nextInstance = instance[collectionName].at(instanceIndex);
-        if (!nextInstance) {
-            return null;
-        }
-        return descendPairs(collection.model, nextInstance, rest);
+    function composeMetadata(value) {
+        const resolved = resolveRef(value, refs);
+        check.assert(BuilderRenderMetadataSchema, resolved, 'Input metadata did not resolve to an object! ❌');
+        return Object.fromEntries(Object.entries(resolved).map(([key, entry]) => [key, resolveRef(entry, refs)]));
     }
     function findCollection(model, instance, collectionName) {
         const entry = model.collections.find((candidate) => candidate.name === collectionName);
-        return entry == null ? null : resolveCollection(entry, instance, refs);
+        return entry == null ? null : resolveCollection(entry, model, instance, refs);
     }
 }
 function setPath(container, path, value) {

package/dist/mappers/resolve.d.ts

@@ -1,5 +1,14 @@
-import type { BuilderCollectionConfigValidated, BuilderCollectionValidated, BuilderComponentDetailsSerialised, BuilderComponentValidated, BuilderOptionValidated, BuilderOptionValuesSerialised, BuilderRefEntities } from '../entities/index';
-export declare function resolveOption(option: BuilderOptionValidated, model: unknown, refs?: BuilderRefEntities): BuilderOptionValuesSerialised | null;
-export declare function resolveComponent(component: BuilderComponentValidated, model: unknown, refs?: BuilderRefEntities): BuilderComponentDetailsSerialised | null;
-export declare function resolveCollection(collection: BuilderCollectionValidated, model: unknown, refs?: BuilderRefEntities): BuilderCollectionConfigValidated | null;
+import type { BuilderCollectionConfigValidated, BuilderCollectionValidated, BuilderComponentDetailsValidated, BuilderComponentValidated, BuilderModelValidated, BuilderOptionValidated, BuilderOptionValuesValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderInstance } from '../instance';
+import type { BuilderPath } from '../paths';
+export declare function resolveOption(option: BuilderOptionValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderOptionValuesValidated | null;
+export declare function resolveComponent(component: BuilderComponentValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderComponentDetailsValidated | null;
+export declare function resolveCollection(collection: BuilderCollectionValidated, model: BuilderModelValidated, instance: unknown, refs?: BuilderRefEntities): BuilderCollectionConfigValidated | null;
 export declare function resolveRef(value: unknown, refs: BuilderRefEntities): unknown;
+export type ResolvedPath = {
+    readonly name: string;
+    readonly payload: BuilderOptionValuesValidated;
+    readonly value: unknown;
+};
+export declare function resolvePath(model: BuilderModelValidated, instance: unknown, path: BuilderPath, refs?: BuilderRefEntities): ResolvedPath | null;
+export declare function resolveItems(model: BuilderModelValidated, instance: unknown, pairs: ReadonlyArray<string | number>, refs?: BuilderRefEntities): readonly [BuilderModelValidated, BuilderInstance] | null;

package/dist/mappers/resolve.js

@@ -1,33 +1,76 @@
+import * as v from 'valibot';
 import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderOptionValuesSerialisedSchema } from '../entities/index.js';
-import { BuilderPathsSchema, readPath } from '../paths.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderOptionValuesSerialisedSchema, BuilderWhenSerialisedSchema, modelsMerge } from '../entities/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, refs = []) {
-    return resolveEntry(option, BuilderOptionValuesSerialisedSchema, model, refs);
+export function resolveOption(option, model, instance, refs = []) {
+    return resolveEntry(option, BuilderOptionValuesSerialisedSchema, model, instance, refs);
 }
-export function resolveComponent(component, model, refs = []) {
-    return resolveEntry(component, BuilderComponentDetailsSerialisedSchema, model, refs);
+export function resolveComponent(component, model, instance, refs = []) {
+    return resolveEntry(component, BuilderComponentDetailsSerialisedSchema, model, instance, refs);
 }
-export function resolveCollection(collection, model, refs = []) {
-    return resolveEntry(collection, BuilderCollectionConfigSerialisedSchema, model, refs);
+export function resolveCollection(collection, model, instance, refs = []) {
+    return resolveEntry(collection, BuilderCollectionConfigSerialisedSchema, model, instance, refs);
 }
 export function resolveRef(value, refs) {
     if (!check.is(BuilderRefSerialisedSchema, value)) {
         return value;
     }
     const found = refs.find((entry) => entry.id === value.id);
-    return found?.serialised ?? value;
+    check.truthy(found, `Reference '${value.id}' not found! ❌`);
+    return found.serialised;
 }
-function resolveEntry(entry, schema, model, refs = []) {
+export function resolvePath(model, instance, path, refs = []) {
+    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);
+    if (descended == null) {
+        return null;
+    }
+    const [scopeModel, scopeInstance] = descended;
+    const merged = modelsMerge(scopeModel);
+    const option = merged.options.find((entry) => entry.name === optionName);
+    check.truthy(option, `Path target '${optionName}' is not an option! ❌`);
+    const payload = resolveOption(option, scopeModel, scopeInstance, refs);
+    if (payload == null) {
+        return null;
+    }
+    return { name: optionName, payload, value: scopeInstance[optionName] };
+}
+export function resolveItems(model, instance, pairs, refs = []) {
+    check.assert(BuilderInstanceSchema, instance);
+    if (pairs.length === 0) {
+        return [model, instance];
+    }
+    const [name, index, ...rest] = pairs;
+    check.assert(v.string(), name);
+    check.assert(v.number(), index, `Collection '${name}' must be followed by an index! ❌`);
+    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);
+    if (resolved == null) {
+        return null;
+    }
+    const items = instance[name];
+    check.assert(BuilderInstancesSchema, items);
+    const item = items.at(index);
+    if (item == null) {
+        return null;
+    }
+    return resolveItems(resolved.model, item, rest, refs);
+}
+function resolveEntry(entry, schema, model, instance, refs = []) {
     const payload = resolveRef(entry.payload, refs);
     if (check.is(schema, payload)) {
         return payload;
     }
+    check.assert(BuilderWhenSerialisedSchema, payload);
     check.assert(BuilderPathsSchema, entry.paths);
-    return pickWhenBranch(payload, entry.paths, model);
-}
-function pickWhenBranch(config, gates, instance) {
-    if (!gates.every((path) => readPath(instance, path) != null)) {
+    const config = payload;
+    if (!entry.paths.every((path) => isPresent(resolvePath(model, instance, path, refs)?.value))) {
         return null;
     }
     switch (config.type) {
@@ -36,10 +79,15 @@ function pickWhenBranch(config, gates, instance) {
         }
         case 'match': {
             const selectMap = config.selectMap;
-            return selectMap[`${readPath(instance, config.matchPath)}`] ?? null;
+            const matched = resolvePath(model, instance, config.matchPath, refs);
+            return selectMap[`${matched?.value}`] ?? null;
         }
         case 'unless': {
-            const value = readPath(instance, config.unlessPath);
+            const value = resolvePath(model, instance, config.unlessPath, refs)?.value;
+            if (!isPresent(value)) {
+                return null;
+            }
+            check.assert(BuilderPrimitiveSchema, value);
             if (config.disabledValues.includes(value)) {
                 return null;
             }
@@ -47,3 +95,12 @@ function pickWhenBranch(config, gates, instance) {
         }
     }
 }
+function isPresent(value) {
+    if (value == null) {
+        return false;
+    }
+    if (typeof value === 'string' && value === '') {
+        return false;
+    }
+    return true;
+}

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

@@ -1 +1,2 @@
-export { createVariants } from './variants.js';
+export { BuilderOptionGraph } from './option-graph.js';
+export { createVariants, optionGraph, variantsFor } from './variants.js';

package/dist/mappers/variants/index.js

@@ -1 +1,2 @@
-export { createVariants } from './variants.js';
+export { BuilderOptionGraph } from './option-graph.js';
+export { createVariants, optionGraph, variantsFor } from './variants.js';

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

@@ -1,4 +1,4 @@
-import type { BuilderOptionValidated, BuilderWhen } from '../../entities/index';
+import type { BuilderModelValidated, BuilderOptionValidated, BuilderWhen } from '../../entities/index';
 import type { BuilderInstances } from '../../instance';
 import type { BuilderPaths } from '../../paths';
 export type GraphKeys = ReadonlySet<string>;
@@ -15,5 +15,5 @@ export declare class BuilderOptionGraph {
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
     get(name: string): GraphPath;
-    add(option: BuilderOptionValidated): BuilderOptionGraph;
+    add(option: BuilderOptionValidated, model: BuilderModelValidated): BuilderOptionGraph;
 }

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

@@ -1,5 +1,6 @@
 import { check } from '../../check.js';
 import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
+import { BuilderPathSchema } from '../../paths.js';
 import { resolveOption } from '../resolve.js';
 export function crossProduct(left, right) {
     return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
@@ -7,10 +8,12 @@ export function crossProduct(left, right) {
 export function dependencyKeys(payload, paths = []) {
     const keys = new Set(paths.map(([first]) => String(first)));
     if (check.is(BuilderWhenMatchSchema, payload)) {
+        check.assert(BuilderPathSchema, payload.matchPath);
         const [firstMatchSegment] = payload.matchPath;
         keys.add(String(firstMatchSegment));
     }
     else if (check.is(BuilderWhenUnlessSchema, payload)) {
+        check.assert(BuilderPathSchema, payload.unlessPath);
         const [firstUnlessSegment] = payload.unlessPath;
         keys.add(String(firstUnlessSegment));
     }
@@ -26,11 +29,11 @@ export class BuilderOptionGraph {
         check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
         return graphPath;
     }
-    add(option) {
+    add(option, model) {
         const { paths, payload } = option;
         const optionDependencyKeys = dependencyKeys(payload, paths);
         if (optionDependencyKeys.length === 0) {
-            const payload = resolveOption(option, {});
+            const payload = resolveOption(option, model, {});
             check.truthy(payload, `Option '${option.name}' without dependencies must resolve! ❌`);
             const values = this.#optionValues(option.name, payload);
             return new BuilderOptionGraph([
@@ -45,7 +48,7 @@ export class BuilderOptionGraph {
         const merged = this.#mergePaths(new Set(optionDependencyKeys), this.paths);
         const finalInstances = [];
         merged.instances.forEach((instance) => {
-            const payload = resolveOption(option, instance);
+            const payload = resolveOption(option, model, instance);
             if (payload) {
                 this.#optionValues(option.name, payload).forEach((value) => {
                     finalInstances.push({ ...instance, [option.name]: value });

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

@@ -1,3 +1,6 @@
-import type { BuilderModelValidated, BuilderValidated } from '../../entities/index';
-import type { BuilderComponentVariants } from '../../instance';
+import type { BuilderCollectionValidated, BuilderComponentValidated, BuilderModelValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderComponentVariants, BuilderInstances } from '../../instance';
+import { BuilderOptionGraph } from './option-graph.js';
 export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+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 { BuilderSerialisedSchema } from '../../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderSerialisedSchema } from '../../entities/index.js';
 import { resolveCollection } from '../resolve.js';
 import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
 export function createVariants(entity) {
@@ -7,10 +7,14 @@ export function createVariants(entity) {
     return buildVariants(model);
 }
 function buildVariants(model) {
-    const options = optionGraph(model.options);
+    const options = optionGraph(model);
     const nestedVariants = model.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
-        const resolved = resolveCollection(entry, instance);
-        return resolved == null ? [] : [buildVariants(resolved.model)];
+        const resolved = resolveCollection(entry, model, instance);
+        if (resolved == null) {
+            return [];
+        }
+        check.assert(BuilderModelSerialisedSchema, resolved.model);
+        return [buildVariants(resolved.model)];
     }));
     return {
         ...nestedVariants.reduce((merged, component) => ({ ...merged, ...component }), {}),
@@ -20,10 +24,10 @@ function buildVariants(model) {
         ]))
     };
 }
-function optionGraph(options) {
-    return options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
+export function optionGraph(model) {
+    return model.options.reduce((graph, option) => graph.add(option, model), new BuilderOptionGraph());
 }
-function variantsFor(entity, options) {
+export function variantsFor(entity, options) {
     const keys = new Set(dependencyKeys(entity.payload, entity.paths));
     const graphPaths = Array.from(keys)
         .map((key) => options.get(key))

package/dist/paths.d.ts

@@ -3,4 +3,3 @@ export declare const BuilderPathSchema: v.SchemaWithPipe<readonly [v.ArraySchema
 export type BuilderPath = v.InferOutput<typeof BuilderPathSchema>;
 export declare const BuilderPathsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
 export type BuilderPaths = v.InferOutput<typeof BuilderPathsSchema>;
-export declare function readPath(model: unknown, path: BuilderPath): unknown;

package/dist/paths.js

@@ -1,11 +1,3 @@
 import * as v from 'valibot';
 export const BuilderPathSchema = v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly());
 export const BuilderPathsSchema = v.pipe(v.array(BuilderPathSchema), v.readonly());
-export function readPath(model, path) {
-    return path.reduce((current, segment) => {
-        if (current == null) {
-            return null;
-        }
-        return current[segment];
-    }, model);
-}

package/dist/validate/brand.d.ts

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

package/dist/validate/brand.js

@@ -1,17 +1,23 @@
-import { builderError, BuilderException } from '../exception.js';
+import { BuilderException } from '../exception.js';
+import { BuilderValidateErrors } from './errors.js';
 const VALIDATED = Symbol('builder.validated');
-export function builderErrorUnvalidated(value, location = []) {
-    return { ...builderError('unvalidated', location), value };
-}
 export function validate(value) {
+    // Descriptor flags chosen for Svelte 5 `$state` proxy compatibility — `$state`
+    // rejects any property that isn't writable, configurable, and enumerable.
+    // Symbol keys are skipped by `JSON.stringify` regardless of enumerability,
+    // so the brand never leaks through a serialise round-trip.
     Object.defineProperty(value, VALIDATED, {
         value: true,
-        enumerable: false
+        writable: true,
+        enumerable: true,
+        configurable: true
     });
     return value;
 }
 export function assertValidated(value) {
     if (typeof value !== 'object' || value === null || !(VALIDATED in value)) {
-        throw new BuilderException([builderErrorUnvalidated(value)]);
+        const errors = new BuilderValidateErrors();
+        errors.unvalidated(value);
+        throw new BuilderException(errors.errors);
     }
 }

package/dist/validate/builder.d.ts

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

package/dist/validate/builder.js

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

package/dist/validate/errors.d.ts

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