@builder-builder/builder 0.0.9 → 0.0.11

package/dist/mappers/{models → variants}/option-graph.js

@@ -1,6 +1,21 @@
 import { check } from '../../check.js';
+import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
 import { resolveOption } from '../resolve.js';
-import { crossProduct, dependencyKeys } from './graph.js';
+export function crossProduct(left, right) {
+    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+}
+export function dependencyKeys(payload, paths = []) {
+    const keys = new Set(paths.map(([first]) => String(first)));
+    if (check.is(BuilderWhenMatchSchema, payload)) {
+        const [firstMatchSegment] = payload.matchPath;
+        keys.add(String(firstMatchSegment));
+    }
+    else if (check.is(BuilderWhenUnlessSchema, payload)) {
+        const [firstUnlessSegment] = payload.unlessPath;
+        keys.add(String(firstUnlessSegment));
+    }
+    return Array.from(keys);
+}
 export class BuilderOptionGraph {
     paths;
     constructor(paths = []) {
@@ -12,43 +27,39 @@ export class BuilderOptionGraph {
         return graphPath;
     }
     add(option) {
-        check.falsy(this.#has(option.name), `Duplicate option name '${option.name}'! ❌`);
-        const { gatePaths, payload } = option;
-        const optionDependencyKeys = dependencyKeys(payload, gatePaths);
+        const { paths, payload } = option;
+        const optionDependencyKeys = dependencyKeys(payload, paths);
         if (optionDependencyKeys.length === 0) {
-            const resolved = resolveOption(option, {});
-            check.truthy(resolved, `Option '${option.name}' without dependencies must resolve! ❌`);
-            const values = this.#optionValues(resolved.name, resolved.payload);
+            const payload = resolveOption(option, {});
+            check.truthy(payload, `Option '${option.name}' without dependencies must resolve! ❌`);
+            const values = this.#optionValues(option.name, payload);
             return new BuilderOptionGraph([
                 ...this.paths,
                 {
                     name: option.name,
                     keys: new Set(),
-                    models: values.map((value) => ({ [option.name]: value }))
+                    instances: values.map((value) => ({ [option.name]: value }))
                 }
             ]);
         }
         const merged = this.#mergePaths(new Set(optionDependencyKeys), this.paths);
-        const finalModels = [];
-        merged.models.forEach((model) => {
-            const result = resolveOption(option, model);
-            if (result) {
-                this.#optionValues(result.name, result.payload).forEach((value) => {
-                    finalModels.push({ ...model, [result.name]: value });
+        const finalInstances = [];
+        merged.instances.forEach((instance) => {
+            const payload = resolveOption(option, instance);
+            if (payload) {
+                this.#optionValues(option.name, payload).forEach((value) => {
+                    finalInstances.push({ ...instance, [option.name]: value });
                 });
             }
             else {
-                finalModels.push({ ...model });
+                finalInstances.push({ ...instance });
             }
         });
         return new BuilderOptionGraph([
             ...this.paths,
-            { name: option.name, keys: merged.keys, models: finalModels }
+            { name: option.name, keys: merged.keys, instances: finalInstances }
         ]);
     }
-    #has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     #mergePaths(dependencyKeys, graphPaths) {
         const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
             const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
@@ -58,9 +69,9 @@ export class BuilderOptionGraph {
         const [first, ...rest] = dependencyPaths;
         return rest.reduce((merged, next) => {
             const keys = new Set([...merged.keys, ...next.keys, next.name]);
-            const models = crossProduct(next.models, merged.models);
-            return { keys, models };
-        }, { keys: new Set([...first.keys, first.name]), models: first.models });
+            const instances = crossProduct(next.instances, merged.instances);
+            return { keys, instances };
+        }, { keys: new Set([...first.keys, first.name]), instances: first.instances });
     }
     #optionValues(name, values) {
         if (values.type === 'select') {

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

@@ -0,0 +1,3 @@
+import type { BuilderModelValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderComponentVariants } from '../../instance';
+export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;

package/dist/mappers/variants/variants.js

@@ -0,0 +1,57 @@
+import { check } from '../../check.js';
+import { BuilderSerialisedSchema } from '../../entities/index.js';
+import { resolveCollection } from '../resolve.js';
+import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
+export function createVariants(entity) {
+    const model = check.is(BuilderSerialisedSchema, entity) ? entity.model : entity;
+    return buildVariants(model);
+}
+function buildVariants(model) {
+    const options = optionGraph(model.options);
+    const nestedVariants = model.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
+        const resolved = resolveCollection(entry, instance);
+        return resolved == null ? [] : [buildVariants(resolved.model)];
+    }));
+    return {
+        ...nestedVariants.reduce((merged, component) => ({ ...merged, ...component }), {}),
+        ...Object.fromEntries(model.components.map((component) => [
+            component.name,
+            variantsFor(component, options).map((instance) => ({ instance }))
+        ]))
+    };
+}
+function optionGraph(options) {
+    return options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
+}
+function variantsFor(entity, options) {
+    const keys = new Set(dependencyKeys(entity.payload, entity.paths));
+    const graphPaths = Array.from(keys)
+        .map((key) => options.get(key))
+        .sort((pathA, pathB) => pathB.keys.size - pathA.keys.size);
+    const handledKeys = new Set();
+    let variants = [{}];
+    graphPaths.forEach((graphPath) => {
+        const isHandled = handledKeys.has(graphPath.name) &&
+            Array.from(graphPath.keys).every((key) => handledKeys.has(key));
+        if (!isHandled) {
+            const pickedInstances = pickKeys(graphPath, keys);
+            variants = crossProduct(variants, pickedInstances);
+            handledKeys.add(graphPath.name);
+            graphPath.keys.forEach((key) => handledKeys.add(key));
+        }
+    });
+    return variants;
+}
+function pickKeys(graphPath, keys) {
+    const seen = new Set();
+    const picked = [];
+    graphPath.instances.forEach((instance) => {
+        const filtered = Object.fromEntries(Object.entries(instance).filter(([key, value]) => keys.has(key) && value != null));
+        const identity = JSON.stringify(filtered);
+        if (identity !== '{}' && !seen.has(identity)) {
+            seen.add(identity);
+            picked.push(filtered);
+        }
+    });
+    return picked;
+}

package/dist/private.d.ts

@@ -0,0 +1,4 @@
+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 { BuilderEnvironmentSchema } from './environment.js';
+export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/private.js

@@ -0,0 +1,4 @@
+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 { BuilderEnvironmentSchema } from './environment.js';
+export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/references.d.ts

@@ -1,60 +1,51 @@
 import * as v from 'valibot';
-export type Refable<Value> = Value | BuilderRef;
-export type RefableSerialised<Value> = Value | BuilderRefSerialised;
-export type RefableMetadata = {
-    readonly refable?: v.GenericSchema;
-};
-export declare class BuilderRef {
+export type Paramable<Value> = Value | BuilderParameter | BuilderRef;
+export type ParamableSerialised<Value> = Value | BuilderParameterSerialised | BuilderRefSerialised;
+export declare class BuilderParameter<const Name extends string = string> {
     readonly id: string;
-    readonly name: string;
-    constructor(name: string, id?: string);
+    readonly name: Name;
+    constructor(name: Name, id?: string);
 }
-export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
-export declare const BuilderRefsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderRef, undefined>, undefined>, v.ReadonlyAction<BuilderRef[]>]>;
-export type BuilderRefs = v.InferOutput<typeof BuilderRefsSchema>;
-export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
+export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
 }>]>;
-export type BuilderRefSerialised = v.InferOutput<typeof BuilderRefSerialisedSchema>;
-export declare const BuilderRefsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export type BuilderParameterSerialised = v.InferOutput<typeof BuilderParameterSerialisedSchema>;
+export declare class BuilderRef {
+    readonly type: "ref";
+    readonly id: string;
+    constructor(id: string);
+}
+export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
+export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
     readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;
-    name: string;
-}>]>, undefined>, v.ReadonlyAction<Readonly<{
-    type: "ref";
-    id: string;
-    name: string;
-}>[]>]>;
-export type BuilderRefsSerialised = v.InferOutput<typeof BuilderRefsSerialisedSchema>;
-export declare function isRef(value: unknown): value is BuilderRef;
-export declare function isSerialisedRef(value: unknown): value is BuilderRefSerialised;
-export declare function parameter(name: string): BuilderRef;
-export declare function refable<Schema extends v.GenericSchema>(refable: Schema): v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+}>]>;
+export type BuilderRefSerialised = v.InferOutput<typeof BuilderRefSerialisedSchema>;
+export declare function parameter<const Name extends string>(name: Name): BuilderParameter<Name>;
+export declare function ref(id: string): BuilderRef;
+export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
-}>]>, v.InstanceSchema<typeof BuilderRef, undefined>, Schema], undefined>, v.MetadataAction<v.InferOutput<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
     readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;
-    name: string;
-}>]> | v.InstanceSchema<typeof BuilderRef, undefined> | Schema>, {
-    readonly refable: Schema;
-}>]>;
+}>]>, Schema], undefined>;
+export declare function isParamable(value: unknown): boolean;

package/dist/references.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { check } from './check.js';
-export class BuilderRef {
+export class BuilderParameter {
     id;
     name;
     constructor(name, id = crypto.randomUUID()) {
@@ -8,19 +8,26 @@ export class BuilderRef {
         this.id = id;
     }
 }
+export const BuilderParameterSchema = v.instance(BuilderParameter);
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
+export class BuilderRef {
+    type = 'ref';
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderRefsSchema = v.pipe(v.array(BuilderRefSchema), v.readonly());
-export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string(), name: v.string() }), v.readonly());
-export const BuilderRefsSerialisedSchema = v.pipe(v.array(BuilderRefSerialisedSchema), v.readonly());
-export function isRef(value) {
-    return check.is(BuilderRefSchema, value);
+export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string() }), v.readonly());
+export function parameter(name) {
+    return new BuilderParameter(name);
 }
-export function isSerialisedRef(value) {
-    return check.is(BuilderRefSerialisedSchema, value);
+export function ref(id) {
+    return new BuilderRef(id);
 }
-export function parameter(name) {
-    return new BuilderRef(name);
+export function paramable(paramable) {
+    return v.union([BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema, paramable]);
 }
-export function refable(refable) {
-    return v.pipe(v.union([BuilderRefSerialisedSchema, BuilderRefSchema, refable]), v.metadata({ refable }));
+export function isParamable(value) {
+    return (check.is(BuilderParameterSerialisedSchema, value) || check.is(BuilderRefSerialisedSchema, value));
 }

package/dist/serialisable.d.ts

@@ -1,10 +1,2 @@
 import * as v from 'valibot';
-export type SerialisableClass = new (...args: ReadonlyArray<never>) => object;
-export type SerialisableMetadata = {
-    readonly serialisable?: SerialisableClass;
-    readonly instance?: v.GenericSchema;
-};
-export declare function serialisable<Serialisable extends SerialisableClass, Schema extends v.GenericSchema>(serialisable: Serialisable, schema: Schema): v.SchemaWithPipe<readonly [Schema, v.MetadataAction<v.InferOutput<Schema>, {
-    readonly serialisable: Serialisable;
-    readonly instance: v.InstanceSchema<Serialisable, undefined>;
-}>, v.ReadonlyAction<v.InferOutput<Schema>>]>;
+export declare function serialisable<Schema extends v.GenericSchema>(schema: Schema): v.SchemaWithPipe<readonly [Schema, v.ReadonlyAction<v.InferOutput<Schema>>]>;

package/dist/serialisable.js

@@ -1,5 +1,4 @@
 import * as v from 'valibot';
-export function serialisable(serialisable, schema) {
-    const instance = v.instance(serialisable);
-    return v.pipe(schema, v.metadata({ serialisable, instance }), v.readonly());
+export function serialisable(schema) {
+    return v.pipe(schema, v.readonly());
 }

package/dist/validate/brand.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,17 @@
+import { builderError, BuilderException } from '../exception.js';
+const VALIDATED = Symbol('builder.validated');
+export function builderErrorUnvalidated(value, location = []) {
+    return { ...builderError('unvalidated', location), value };
+}
+export function validate(value) {
+    Object.defineProperty(value, VALIDATED, {
+        value: true,
+        enumerable: false
+    });
+    return value;
+}
+export function assertValidated(value) {
+    if (typeof value !== 'object' || value === null || !(VALIDATED in value)) {
+        throw new BuilderException([builderErrorUnvalidated(value)]);
+    }
+}

package/dist/validate/builder.d.ts

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

package/dist/validate/builder.js

@@ -0,0 +1,27 @@
+import { check } from '../check.js';
+import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
+import { validate } from './brand.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 = []) {
+    if (!check.is(BuilderSerialisedSchema, input)) {
+        const errors = [builderErrorInvalidInput('builder')];
+        return [validate(serialise.builder(builder())), errors];
+    }
+    const resolve = resolver(references, input.bindings);
+    const [validatedModel, modelErrors] = validateModelStructure(input.model, resolve, ['model']);
+    const [validatedUI, uiErrors] = validateUIStructure(input.ui, resolve, ['ui']);
+    const mergedModel = modelsMerge(validatedModel);
+    const expectationErrors = [
+        ...checkModelExpectations(mergedModel, validatedModel, ['model']),
+        ...checkUIExpectations(mergedModel, validatedUI, ['ui'])
+    ];
+    const data = validate({
+        ...serialise.builder(builder()),
+        model: mergedModel,
+        ui: validatedUI
+    });
+    return [data, [...expectationErrors, ...modelErrors, ...uiErrors]];
+}

package/dist/validate/expectations.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderExpectationKind, BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+export declare function builderErrorUnmetExpectation(expectationKind: BuilderExpectationKind, name: string, location?: BuilderErrorLocation): {
+    expectationKind: "option" | "component" | "collection";
+    name: string;
+    kind: "unmet-expectation";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnmetExpectation = ReturnType<typeof builderErrorUnmetExpectation>;
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, location: BuilderErrorLocation): BuilderErrors;

package/dist/validate/expectations.js

@@ -0,0 +1,12 @@
+import { builderError } from '../exception.js';
+export function builderErrorUnmetExpectation(expectationKind, name, location = []) {
+    return { ...builderError('unmet-expectation', location), expectationKind, name };
+}
+export function checkExpectations(model, expectations, location) {
+    return expectations.flatMap(({ kind, name }, index) => {
+        if (model[`${kind}s`].some((entry) => entry.name === name)) {
+            return [];
+        }
+        return [builderErrorUnmetExpectation(kind, name, [...location, index])];
+    });
+}

package/dist/validate/index.d.ts

@@ -0,0 +1,18 @@
+export type { BuilderErrorUnvalidated } from './brand';
+export type { BuilderValidationResult } from './builder';
+export type { BuilderErrorUnmetExpectation } from './expectations';
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderInstanceValidationResult } from './instance';
+export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderModelValidationResult } from './model';
+export type { BuilderErrorMissingReference, BuilderErrorUnboundParameter } from './resolve';
+export type { BuilderErrorInvalidInput } from './result';
+export type { BuilderUIValidationResult } from './ui';
+export type { BuilderComponentVariantsValidationResult, BuilderErrorInvalidDetail, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderVariantsValidationOptions } from './variants';
+export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { validateBuilder } from './builder.js';
+export { builderErrorUnmetExpectation } from './expectations.js';
+export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
+export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
+export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
+export { builderErrorInvalidInput } from './result.js';
+export { validateUI } from './ui.js';
+export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';

package/dist/validate/index.js

@@ -0,0 +1,9 @@
+export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { validateBuilder } from './builder.js';
+export { builderErrorUnmetExpectation } from './expectations.js';
+export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
+export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
+export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
+export { builderErrorInvalidInput } from './result.js';
+export { validateUI } from './ui.js';
+export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';

package/dist/validate/instance.d.ts

@@ -0,0 +1,19 @@
+import type { BuilderInstanceValidated, BuilderModelValidated } from '../entities/index';
+import type { BuilderErrorLocation } from '../exception';
+import type { BuilderInstance } from '../instance';
+import type { ValidationResult } from './result';
+export declare function builderErrorInvalidOption(name: string, value: unknown, location?: BuilderErrorLocation): {
+    name: string;
+    value: unknown;
+    kind: "invalid-option";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidOption = ReturnType<typeof builderErrorInvalidOption>;
+export declare function builderErrorInvalidCollection(name: string, location?: BuilderErrorLocation): {
+    name: string;
+    kind: "invalid-collection";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidCollection = ReturnType<typeof builderErrorInvalidCollection>;
+export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -0,0 +1,46 @@
+import { check } from '../check.js';
+import { optionValueSchema } from '../entities/index.js';
+import { builderError } from '../exception.js';
+import { resolveCollection, resolveOption } from '../mappers/index.js';
+import { validate } from './brand.js';
+export function builderErrorInvalidOption(name, value, location = []) {
+    return { ...builderError('invalid-option', location), name, value };
+}
+export function builderErrorInvalidCollection(name, location = []) {
+    return { ...builderError('invalid-collection', location), name };
+}
+export function validateInstance(model, instance) {
+    const errors = checkInstance(model, instance, ['instance']);
+    return [validate(instance), errors];
+}
+function checkInstance(model, instance, location) {
+    const { options, collections } = model;
+    const optionErrors = options.flatMap((option) => {
+        const { name } = option;
+        const payload = resolveOption(option, instance);
+        if (!payload) {
+            return [];
+        }
+        const value = instance[name];
+        if (!check.is(optionValueSchema(payload), value)) {
+            return [builderErrorInvalidOption(name, value, [...location, name])];
+        }
+        return [];
+    });
+    const collectionErrors = collections.flatMap((collection) => {
+        const { name } = collection;
+        const payload = resolveCollection(collection, instance);
+        if (!payload) {
+            return [];
+        }
+        const existing = instance[name];
+        if (!Array.isArray(existing)) {
+            return [builderErrorInvalidCollection(name, [...location, name])];
+        }
+        return existing.flatMap((itemInstance, index) => checkInstance(payload.model, itemInstance, [...location, name, index]).map((error) => ({
+            ...error,
+            name: `${name}[${index}].${error.name}`
+        })));
+    });
+    return [...optionErrors, ...collectionErrors];
+}

package/dist/validate/model.d.ts

@@ -0,0 +1,36 @@
+import type { BuilderModelSerialised, BuilderModelValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { ParamableSerialised } from '../references';
+import type { BuilderResolve } from './resolve';
+import type { ValidationResult } from './result';
+export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
+export declare function builderErrorDuplicateName(name: string, location?: BuilderErrorLocation): {
+    name: string;
+    kind: "duplicate-name";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorDuplicateName = ReturnType<typeof builderErrorDuplicateName>;
+export declare function builderErrorInvalidCollectionBounds(name: string, min: number, max: number, location?: BuilderErrorLocation): {
+    name: string;
+    min: number;
+    max: number;
+    kind: "invalid-collection-bounds";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidCollectionBounds = ReturnType<typeof builderErrorInvalidCollectionBounds>;
+export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
+export declare function builderErrorInvalidPath(reason: BuilderErrorInvalidPathReason, location?: BuilderErrorLocation): {
+    reason: BuilderErrorInvalidPathReason;
+    kind: "invalid-path";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidPath = ReturnType<typeof builderErrorInvalidPath>;
+export declare function builderErrorInvalidSelectMapKey(key: string, location?: BuilderErrorLocation): {
+    key: string;
+    kind: "invalid-select-map-key";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidSelectMapKey = ReturnType<typeof builderErrorInvalidSelectMapKey>;
+export declare function validateModel(input: unknown, references?: BuilderRefEntities): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, model: BuilderModelSerialised, location: BuilderErrorLocation): BuilderErrors;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, location: BuilderErrorLocation): BuilderModelValidationResult;