@builder-builder/builder 0.0.5 → 0.0.7

package/dist/core/builder.d.ts

@@ -4,6 +4,7 @@ import type { BuilderComponentEntries, BuilderComponentMethod } from './componen
 import type { BuilderOptionEntries, BuilderOptionMethod } from './option/index';
 import type { BuilderBindings, BuilderBoundState } from './parameter';
 import type { BuilderExpectationEntries, BuilderExpectations, ComponentAssert, ModelAssert } from './expectation';
+import { validateBuilder } from './validate.js';
 import { BuilderComponentGraph } from './component/index.js';
 import { BuilderOptionGraph } from './option/index.js';
 export type BuilderState = {
@@ -42,7 +43,7 @@ export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
     readonly expectations: BuilderExpectationEntries;
-    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries, expectations?: BuilderExpectationEntries);
+    constructor(options?: BuilderOptionEntries, components?: BuilderComponentEntries, collections?: BuilderCollectionEntries, expectations?: BuilderExpectationEntries);
     get optionGraph(): BuilderOptionGraph;
     get componentGraph(): BuilderComponentGraph;
     get option(): BuilderOptionMethod<State>;
@@ -55,7 +56,10 @@ export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     }>;
     bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
 }
-export declare function builder<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+declare function mergeBuilders<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+export declare const builder: typeof mergeBuilders & {
+    validate: typeof validateBuilder;
+};
 type MergedPartsState<Parts extends ReadonlyArray<BuilderGeneric>> = Parts extends readonly [
     infer Head extends BuilderGeneric,
     ...infer Tail extends ReadonlyArray<BuilderGeneric>

package/dist/core/builder.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { BuilderExpectation } from './expectation.js';
 import { check } from '../check.js';
+import { validateBuilder } from './validate.js';
 import { BuilderCollection, resolveCollectionNames } from './collection/index.js';
 import { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 import { BuilderOption, BuilderOptionGraph } from './option/index.js';
@@ -12,10 +12,10 @@ export class Builder {
     expectations;
     #optionGraph = null;
     #componentGraph = null;
-    constructor(options = [], collections = [], components = [], expectations = []) {
+    constructor(options = [], components = [], collections = [], expectations = []) {
         this.options = options;
-        this.collections = collections;
         this.components = components;
+        this.collections = collections;
         this.expectations = expectations;
     }
     get optionGraph() {
@@ -35,17 +35,20 @@ export class Builder {
         return this.#componentGraph;
     }
     get option() {
+        const existingNames = new Set(this.options.map((entry) => entry.name));
         const addOption = (name, values) => {
+            check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
             const entry = new BuilderOption(name, values);
-            return this.#next([...this.options, entry], this.collections, this.components);
+            return this.#next([...this.options, entry], this.components, this.collections);
         };
         const addConditionalOption = (gatePaths, name, config) => {
+            check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
             if (v.is(v.instance(BuilderParameter), config)) {
                 const entry = new BuilderOption(name, config, gatePaths, null);
-                return this.#next([...this.options, entry], this.collections, this.components);
+                return this.#next([...this.options, entry], this.components, this.collections);
             }
             const entry = new BuilderOption(name, extractValues(config), gatePaths, config);
-            return this.#next([...this.options, entry], this.collections, this.components);
+            return this.#next([...this.options, entry], this.components, this.collections);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addOption, { when: addConditionalOption });
@@ -55,12 +58,12 @@ export class Builder {
         const addComponent = (name, paths) => {
             check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths);
-            return this.#next(this.options, this.collections, [...this.components, entry]);
+            return this.#next(this.options, [...this.components, entry], this.collections);
         };
         const addConditionalComponent = (dependencies, name, paths) => {
             check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths, dependencies);
-            return this.#next(this.options, this.collections, [...this.components, entry]);
+            return this.#next(this.options, [...this.components, entry], this.collections);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addComponent, { when: addConditionalComponent });
@@ -71,7 +74,7 @@ export class Builder {
             check.falsy(existing.has(name), `Duplicate collection name '${name}'! ❌`);
             check.assert(v.instance(Builder), collectionRecipe);
             const entry = new BuilderCollection(name, collectionRecipe, min, max);
-            return this.#next(this.options, [...this.collections, entry], this.components);
+            return this.#next(this.options, this.components, [...this.collections, entry]);
         };
         const addConditionalCollection = (gatePaths, name, config) => {
             const existing = resolveCollectionNames(this.collections);
@@ -80,13 +83,13 @@ export class Builder {
                 ? Object.values(config.selectMap).find((value) => value !== null)
                 : config;
             const entry = new BuilderCollection(name, defaultEntry.builder, defaultEntry.min, defaultEntry.max, gatePaths, config);
-            return this.#next(this.options, [...this.collections, entry], this.components);
+            return this.#next(this.options, this.components, [...this.collections, entry]);
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addCollection, { when: addConditionalCollection });
     }
     expect(...expectations) {
-        return new Builder(this.options, this.collections, this.components, [
+        return new Builder(this.options, this.components, this.collections, [
             ...this.expectations,
             ...expectations
             // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
@@ -94,25 +97,13 @@ export class Builder {
     }
     bind(bindings) {
         const boundOptions = bindOptions(this.options, bindings);
-        return new Builder(boundOptions, this.collections, this.components, this.expectations);
+        return new Builder(boundOptions, this.components, this.collections, this.expectations);
     }
-    #next(options, collections, components) {
-        return new Builder(options, collections, components, this.expectations);
+    #next(options, components, collections) {
+        return new Builder(options, components, collections, this.expectations);
     }
 }
-export function builder(...buildersToMerge) {
-    const merged = new Builder(buildersToMerge.flatMap((builder) => builder.options), buildersToMerge.flatMap((builder) => builder.collections), buildersToMerge.flatMap((builder) => builder.components));
-    buildersToMerge
-        .flatMap((builder) => builder.expectations)
-        .forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation)) {
-            if (expectation.kind === 'option') {
-                expectation.validate(merged.options);
-            }
-            else if (expectation.kind === 'component') {
-                expectation.validate(merged.components);
-            }
-        }
-    });
-    return merged;
+function mergeBuilders(...buildersToMerge) {
+    return new Builder(buildersToMerge.flatMap((builder) => builder.options), buildersToMerge.flatMap((builder) => builder.components), buildersToMerge.flatMap((builder) => builder.collections), buildersToMerge.flatMap((builder) => builder.expectations));
 }
+export const builder = Object.assign(mergeBuilders, { validate: validateBuilder });

package/dist/core/collection/collection.d.ts

@@ -11,7 +11,9 @@ export type BuilderCollectionEntries = ReadonlyArray<BuilderCollection>;
 export type TupleOf<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : TupleOf<Item, Length, [...Result, Item]>;
 export type CollectionShape<Item, Min extends number, Max extends number> = number extends Min ? ReadonlyArray<Item> : number extends Max ? ReadonlyArray<Item> : Min extends Max ? TupleOf<Item, Min> : ReadonlyArray<Item>;
 export type BuilderCollectionOf<Builder extends BuilderGeneric, Name extends string> = CollectionOf<BuilderStateOf<Builder>['collections'], Name>;
-export type BuilderCollectionNamesOf<Builder extends BuilderGeneric> = CollectionNamesOf<BuilderStateOf<Builder>['collections']>;
+export type BuilderCollectionNamesOf<Builder extends BuilderGeneric | null> = [Builder] extends [
+    BuilderGeneric
+] ? CollectionNamesOf<BuilderStateOf<Builder>['collections']> : never;
 export type BuilderCollectionModelOf<CollectionRecipe extends BuilderGeneric, Min extends number, Max extends number> = CollectionShape<BuilderModelOf<CollectionRecipe>, Min, Max>;
 export declare class BuilderCollection<const Name extends string = string, const CollectionRecipe = any, const Min extends number = number, const Max extends number = number> implements BuilderCollectionConfig<CollectionRecipe, Min, Max> {
     readonly name: Name;

package/dist/core/component/component.d.ts

@@ -1,11 +1,9 @@
 import type { BuilderPaths } from '../../paths';
 export type BuilderComponentEntries = ReadonlyArray<BuilderComponent>;
-export type BuilderComponentMap = Record<string, BuilderComponent>;
 export type BuilderComponentNamesOf<Components extends BuilderComponentEntries> = Components[number]['name'];
 export declare class BuilderComponent<const Name extends string = string> {
     readonly name: Name;
     readonly paths: BuilderPaths;
     readonly dependencies: ReadonlyArray<string>;
     constructor(name: Name, paths: BuilderPaths, dependencies?: ReadonlyArray<string>);
-    resolve(resolved: BuilderComponentMap): BuilderComponent<Name> | null;
 }

package/dist/core/component/component.js

@@ -7,11 +7,4 @@ export class BuilderComponent {
         this.paths = paths;
         this.dependencies = dependencies;
     }
-    resolve(resolved) {
-        if (this.dependencies.length === 0) {
-            return this;
-        }
-        const ready = this.dependencies.every((dependency) => !!resolved[dependency]);
-        return ready ? this : null;
-    }
 }

package/dist/core/component/graph.d.ts

@@ -5,6 +5,5 @@ export declare class BuilderComponentGraph {
     #private;
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
-    has(name: string): boolean;
     add(component: BuilderComponent, options: BuilderOptionGraph): BuilderComponentGraph;
 }

package/dist/core/component/graph.js

@@ -6,16 +6,16 @@ export class BuilderComponentGraph {
     constructor(paths = []) {
         this.paths = paths;
     }
-    has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     add(component, options) {
-        check.falsy(this.has(component.name), `Duplicate component name '${component.name}'! ❌`);
-        const keys = new Set(component.paths.map((path) => String(path[0])));
+        check.falsy(this.#has(component.name), `Duplicate component name '${component.name}'! ❌`);
+        const keys = new Set(component.paths.map(([first]) => String(first)));
         const models = this.#mergeModels(keys, options);
         const newPath = { name: component.name, keys, models };
         return new BuilderComponentGraph([...this.paths, newPath]);
     }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
     #mergeModels(keys, options) {
         const graphPaths = Array.from(keys)
             .map((key) => options.get(key))

package/dist/core/component/index.d.ts

@@ -1,4 +1,4 @@
-export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentNamesOf } from './component';
+export type { BuilderComponentEntries, BuilderComponentNamesOf } from './component';
 export type { BuilderComponentMethod } from './method';
 export { BuilderComponent } from './component.js';
 export { BuilderComponentGraph } from './graph.js';

package/dist/core/expectation.d.ts

@@ -1,39 +1,42 @@
-import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
 import type { Prettify } from '../prettify';
+import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
+import { BuilderCollection } from './collection/index.js';
 import { BuilderComponent } from './component/index.js';
-export type BuilderExpectationKind = 'option' | 'component';
+export type BuilderExpectationKind = 'option' | 'component' | 'collection';
 export type BuilderExpectationEntries = ReadonlyArray<BuilderExpectation>;
 export type BuilderExpectations = readonly [
     BuilderExpectation,
     ...ReadonlyArray<BuilderExpectation>
 ];
-export type BuilderModelAsserted<BuilderInput extends BuilderGeneric, Expectations extends BuilderExpectations> = BuilderMerge<BuilderStateOf<BuilderInput>, {
-    model: ModelAssert<BuilderInput, Expectations>;
-    components: ComponentAssert<BuilderInput, Expectations>;
+export type BuilderModelAsserted<BuilderInput extends BuilderGeneric | null, Expectations extends BuilderExpectations, Resolved extends BuilderGeneric = [BuilderInput] extends [BuilderGeneric] ? BuilderInput : BuilderGeneric> = BuilderMerge<BuilderStateOf<Resolved>, {
+    model: ModelAssert<Resolved, Expectations>;
+    components: ComponentAssert<Resolved, Expectations>;
+    collections: CollectionAssert<Resolved, Expectations>;
 }>;
 export type ModelAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedModel<Items> = ExpectedModel<Items>> = unknown extends Current['model'] ? Prettify<Asserted> : Prettify<Current['model'] & Asserted>;
 export type ComponentAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedComponents<Items> = ExpectedComponents<Items>> = Current['components'] extends [] ? ExpectedComponents<Items> : number extends Asserted['length'] ? Asserted : [...Current['components'], ...Asserted];
-export declare class BuilderExpectation<Name extends string = string, Value = unknown> {
+export type CollectionAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedCollections<Items> = ExpectedCollections<Items>> = Current['collections'] extends [] ? ExpectedCollections<Items> : number extends Asserted['length'] ? Asserted : [...Current['collections'], ...Asserted];
+export declare class BuilderExpectation<Name extends string = string, Value = unknown, Kind extends BuilderExpectationKind = BuilderExpectationKind> {
     readonly name: Name;
-    readonly kind: BuilderExpectationKind;
-    constructor(name: Name, kind: BuilderExpectationKind);
-    optional(): BuilderExpectation<Name, Value | null>;
-    validate(entries: ReadonlyArray<{
-        readonly name: string;
-    }>): void;
+    readonly kind: Kind;
+    constructor(name: Name, kind: Kind);
+    optional(): BuilderExpectation<Name, Value | null, Kind>;
 }
-export declare const option: {
-    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, string>;
-};
-export declare const component: {
-    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, never>;
+export declare const has: {
+    option: <const Name extends string>(name: Name) => BuilderExpectation<Name, string, "option">;
+    component: <const Name extends string>(name: Name) => BuilderExpectation<Name, never, "component">;
+    collection: <const Name extends string>(name: Name) => BuilderExpectation<Name, unknown, "collection">;
 };
 type ExpectedModel<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
     infer Head,
     ...infer Tail extends ReadonlyArray<BuilderExpectation>
-] ? (Head extends BuilderExpectation<infer Name, infer Value> ? [Value] extends [never] ? unknown : Record<Name, Value> : unknown) & ExpectedModel<Tail> : unknown;
+] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : Head extends BuilderExpectation<infer Name, any, 'collection'> ? Record<Name, ReadonlyArray<unknown>> : unknown) & ExpectedModel<Tail> : unknown;
 type ExpectedComponents<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
     infer Head,
     ...infer Tail extends ReadonlyArray<BuilderExpectation>
-] ? Head extends BuilderExpectation<infer Name, ReadonlyArray<any>> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
+] ? Head extends BuilderExpectation<infer Name, any, 'component'> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
+type ExpectedCollections<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
+    infer Head,
+    ...infer Tail extends ReadonlyArray<BuilderExpectation>
+] ? Head extends BuilderExpectation<infer Name, any, 'collection'> ? [BuilderCollection<Name>, ...ExpectedCollections<Tail>] : ExpectedCollections<Tail> : [];
 export {};

package/dist/core/expectation.js

@@ -1,5 +1,5 @@
+import { BuilderCollection } from './collection/index.js';
 import { BuilderComponent } from './component/index.js';
-import { check } from '../check.js';
 export class BuilderExpectation {
     name;
     kind;
@@ -10,13 +10,9 @@ export class BuilderExpectation {
     optional() {
         return new BuilderExpectation(this.name, this.kind);
     }
-    validate(entries) {
-        check.truthy(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
-    }
 }
-export const option = {
-    expect: (name) => new BuilderExpectation(name, 'option')
-};
-export const component = {
-    expect: (name) => new BuilderExpectation(name, 'component')
+export const has = {
+    option: (name) => new BuilderExpectation(name, 'option'),
+    component: (name) => new BuilderExpectation(name, 'component'),
+    collection: (name) => new BuilderExpectation(name, 'collection')
 };

package/dist/core/index.d.ts

@@ -1,12 +1,14 @@
 export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './collection/index';
-export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentMethod, BuilderComponentNamesOf } from './component/index';
+export type { BuilderComponentEntries, BuilderComponentMethod, BuilderComponentNamesOf } from './component/index';
 export type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAsserted } from './expectation';
 export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionValuesMap, BuilderOptionWhenConfig, BuilderSelectTypeLabels, BuilderSelectTypeValues } from './option/index';
 export type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig } from './when/index';
 export type { BuilderMerge, BuilderGeneric, BuilderModelOf, Builders, BuilderState, BuilderStateEmpty, BuilderStateOf } from './builder';
+export type { BuilderValidated, BuilderValidateError, BuilderValidateErrors, BuilderValidateErrorUnboundParameter, BuilderValidateErrorUnmetExpectation, BuilderValidateOptions, BuilderValidateResult } from './validate';
 export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
-export { BuilderExpectation, component, option } from './expectation.js';
+export { BuilderExpectation, has } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
 export { BuilderParameter, BuilderParameterSchema } from './parameter.js';
+export { BuilderValidateException } from './validate.js';

package/dist/core/index.js

@@ -1,6 +1,7 @@
 export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
-export { BuilderExpectation, component, option } from './expectation.js';
+export { BuilderExpectation, has } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
 export { BuilderParameter, BuilderParameterSchema } from './parameter.js';
+export { BuilderValidateException } from './validate.js';

package/dist/core/option/graph.d.ts

@@ -2,10 +2,9 @@ import type { GraphPath, GraphPaths } from '../graph';
 import { BuilderOption } from './option.js';
 export type BuilderOptionGraphs = ReadonlyArray<BuilderOptionGraph>;
 export declare class BuilderOptionGraph {
+    #private;
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
-    static merge(...graphs: BuilderOptionGraphs): BuilderOptionGraph;
-    has(name: string): boolean;
     get(name: string): GraphPath;
     add(option: BuilderOption): BuilderOptionGraph;
 }

package/dist/core/option/graph.js

@@ -8,18 +8,13 @@ export class BuilderOptionGraph {
     constructor(paths = []) {
         this.paths = paths;
     }
-    static merge(...graphs) {
-        return new BuilderOptionGraph(graphs.flatMap((graph) => graph.paths));
-    }
-    has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     get(name) {
         const graphPath = this.paths.find((graphPath) => graphPath.name === name);
         check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
         return graphPath;
     }
     add(option) {
+        check.falsy(this.#has(option.name), `Duplicate option name '${option.name}'! ❌`);
         const dependencyKeys = option.dependencyKeys();
         if (dependencyKeys.length === 0) {
             const values = optionValues(option);
@@ -50,6 +45,9 @@ export class BuilderOptionGraph {
             { name: option.name, keys: merged.keys, models: finalModels }
         ]);
     }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
 }
 function mergePaths(dependencyKeys, graphPaths) {
     const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {

package/dist/core/option/index.d.ts

@@ -2,6 +2,7 @@ export type { BuilderOptionEnableConfig, BuilderOptionMatchConfig, BuilderOption
 export type { BuilderOptionGraphs } from './graph';
 export type { BuilderOptionEntries, BuilderOptionValues, BuilderOptionValuesMap, BuilderSelectTypeGeneric, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option';
 export type { BuilderSelectTypeLabels, BuilderSelectTypeValues } from './select';
+export type { BuilderToggleValueType } from './toggle';
 export { enable, match, unless } from './method.js';
 export { BuilderOptionGraph } from './graph.js';
 export { BuilderOption } from './option.js';

package/dist/core/option/option.js

@@ -28,13 +28,14 @@ export class BuilderOption {
         });
     }
     dependencyKeys() {
-        const keys = new Set(this.gatePaths.map((path) => String(path[0])));
+        const keys = new Set(this.gatePaths.map(([first]) => String(first)));
         if (this.config?.type === 'match') {
-            const matchPath = this.config.matchPath;
-            keys.add(String(matchPath[0]));
+            const [firstMatchSegment] = this.config.matchPath;
+            keys.add(String(firstMatchSegment));
         }
         else if (this.config?.type === 'unless') {
-            keys.add(String(this.config.unlessPath[0]));
+            const [firstUnlessSegment] = this.config.unlessPath;
+            keys.add(String(firstUnlessSegment));
         }
         return Array.from(keys);
     }

package/dist/core/option/toggle.d.ts

@@ -1,11 +1,13 @@
 import type { BuilderOptionValueSchema } from './option';
 import * as v from 'valibot';
+export type BuilderToggleValueType = 'string' | 'boolean' | 'number';
 export declare class BuilderToggleType<const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
     readonly value: v.InferOutput<ValueSchema>;
+    readonly valueType: BuilderToggleValueType;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    constructor(valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    constructor(valueType: BuilderToggleValueType, valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
     default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
     optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
 }

package/dist/core/option/toggle.js

@@ -1,27 +1,29 @@
 import * as v from 'valibot';
 export class BuilderToggleType {
+    valueType;
     valueSchema;
     defaultValue;
     isOptional;
-    constructor(valueSchema, defaultValue, optional) {
+    constructor(valueType, valueSchema, defaultValue, optional) {
+        this.valueType = valueType;
         this.valueSchema = valueSchema;
         this.defaultValue = defaultValue;
         this.isOptional = optional || false;
     }
     default(newDefault) {
-        return new BuilderToggleType(this.valueSchema, newDefault, this.isOptional);
+        return new BuilderToggleType(this.valueType, this.valueSchema, newDefault, this.isOptional);
     }
     optional() {
-        const { valueSchema, defaultValue } = this;
-        return new BuilderToggleType(v.nullable(valueSchema), defaultValue, true);
+        const { valueType, valueSchema, defaultValue } = this;
+        return new BuilderToggleType(valueType, v.nullable(valueSchema), defaultValue, true);
     }
 }
 export function toggleString() {
-    return new BuilderToggleType(v.string(), '');
+    return new BuilderToggleType('string', v.string(), '');
 }
 export function toggleBoolean() {
-    return new BuilderToggleType(v.boolean(), false);
+    return new BuilderToggleType('boolean', v.boolean(), false);
 }
 export function toggleNumber() {
-    return new BuilderToggleType(v.number(), 0);
+    return new BuilderToggleType('number', v.number(), 0);
 }

package/dist/core/validate.d.ts

@@ -0,0 +1,26 @@
+import type { BuilderGeneric } from './builder';
+declare const validated: unique symbol;
+export type BuilderValidated = BuilderGeneric & {
+    readonly [validated]: true;
+};
+export type BuilderValidateErrorUnmetExpectation = {
+    readonly kind: 'unmet-expectation';
+    readonly expectationKind: 'option' | 'component' | 'collection';
+    readonly name: string;
+};
+export type BuilderValidateErrorUnboundParameter = {
+    readonly kind: 'unbound-parameter';
+    readonly name: string;
+};
+export type BuilderValidateError = BuilderValidateErrorUnmetExpectation | BuilderValidateErrorUnboundParameter;
+export type BuilderValidateErrors = ReadonlyArray<BuilderValidateError>;
+export type BuilderValidateResult = readonly [BuilderValidated, BuilderValidateErrors];
+export type BuilderValidateOptions = {
+    readonly strict: true;
+};
+export declare class BuilderValidateException extends Error {
+    readonly errors: BuilderValidateErrors;
+    constructor(errors: BuilderValidateErrors);
+}
+export declare function validateBuilder(builder: BuilderGeneric, options?: BuilderValidateOptions): BuilderValidateResult;
+export {};

package/dist/core/validate.js

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+import { BuilderParameterSchema } from './parameter.js';
+export class BuilderValidateException extends Error {
+    errors;
+    constructor(errors) {
+        super('builder validation failed');
+        this.errors = errors;
+    }
+}
+export function validateBuilder(builder, options) {
+    const expectationErrors = validateExpectations(builder.expectations, builder);
+    const parameterErrors = validateParameters(builder.options);
+    const errors = [...expectationErrors, ...parameterErrors];
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderValidateException(errors);
+    }
+    return [builder, errors];
+}
+function validateExpectations(expectations, entries) {
+    return expectations.flatMap((expectation) => {
+        const lookup = expectation.kind === 'option'
+            ? entries.options
+            : expectation.kind === 'component'
+                ? entries.components
+                : entries.collections;
+        const exists = lookup.some((entry) => entry.name === expectation.name);
+        if (exists) {
+            return [];
+        }
+        return [
+            {
+                kind: 'unmet-expectation',
+                expectationKind: expectation.kind,
+                name: expectation.name
+            }
+        ];
+    });
+}
+function validateParameters(options) {
+    return options
+        .filter((option) => v.is(BuilderParameterSchema, option.values))
+        .map((option) => ({ kind: 'unbound-parameter', name: option.name }));
+}

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 export type { BuilderData, BuilderModel, BuilderModels, BuilderPrimitive, BuilderPrimitives, BuilderVariant, BuilderVariants } from './model';
-export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries } from './core/index';
+export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries, BuilderValidated, BuilderValidateError, BuilderValidateErrors, BuilderValidateErrorUnboundParameter, BuilderValidateErrorUnmetExpectation, BuilderValidateOptions, BuilderValidateResult } from './core/index';
 export type { BuilderModelPaths, BuilderResolvePath, BuilderValidPath } from './paths';
 export type { BuilderPath, BuilderPaths } from './schemas/index';
-export type { BuilderDataValidated, BuilderDescription, BuilderDescriptionItem, BuilderErrorComponentMissing, BuilderErrorComponentUnexpected, BuilderErrorsValidate, BuilderErrorValidate, BuilderErrorVariantInvalid, BuilderErrorVariantMissing, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderValidateResult } from './resolve/index';
+export type { BuilderDataValidated, BuilderDataError, BuilderDataErrors, BuilderDataErrorComponentMissing, BuilderDataErrorComponentUnexpected, BuilderDataErrorVariantInvalid, BuilderDataErrorVariantMissing, BuilderDataValidateResult, BuilderDescription, BuilderDescriptionItem, BuilderModelValidated, BuilderModelValidateError, BuilderModelValidateErrors, BuilderModelValidateErrorInvalidCollection, BuilderModelValidateErrorInvalidOption, BuilderModelValidateOptions, BuilderModelValidateResult, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './resolve/index';
 export type { BuilderUICollection, BuilderUIDescribe, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './schemas/index';
-export type { BuilderUI, BuilderUIFactory, BuilderUIs } from './ui';
-export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
-export { BuilderExpectation, component, option } from './core/index.js';
+export type { BuilderUI, BuilderUIs } from './ui';
+export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderSerialisedValidated, BuilderSerialisedError, BuilderSerialisedErrors, BuilderSerialisedValidateOptions, BuilderSerialisedValidateResult, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
+export { BuilderExpectation, BuilderValidateException, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
-export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
-export { deserialise, serialise } from './serialise/index.js';
+export { instance, BuilderModelValidateException, models, order, ordinal, render, validate, BuilderDataValidateError } from './resolve/index.js';
+export { BuilderSerialisedValidateError, deserialise, serialise } from './serialise/index.js';
 export { ui } from './ui.js';

package/dist/index.js

@@ -1,5 +1,5 @@
-export { BuilderExpectation, component, option } from './core/index.js';
+export { BuilderExpectation, BuilderValidateException, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
-export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
-export { deserialise, serialise } from './serialise/index.js';
+export { instance, BuilderModelValidateException, models, order, ordinal, render, validate, BuilderDataValidateError } from './resolve/index.js';
+export { BuilderSerialisedValidateError, deserialise, serialise } from './serialise/index.js';
 export { ui } from './ui.js';

package/dist/paths.d.ts

@@ -5,7 +5,9 @@ export type BuilderValidPath<Model, Depth extends ReadonlyArray<never> = []> = D
     [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...BuilderValidPath<Model[Key], [...Depth, never]>]);
 }[keyof Model & string];
 export type BuilderValidPaths<Model> = ReadonlyArray<BuilderValidPath<Model>>;
-export type BuilderModelPaths<Builder extends BuilderGeneric> = BuilderValidPaths<BuilderModelOf<Builder>>;
+export type BuilderModelPaths<Builder extends BuilderGeneric | null> = [Builder] extends [
+    BuilderGeneric
+] ? BuilderValidPaths<BuilderModelOf<Builder>> : ReadonlyArray<never>;
 export type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Model & string
 ] ? Model[Head] : Path extends readonly [

package/dist/resolve/index.d.ts

@@ -1,9 +1,10 @@
 export type { BuilderOrder } from './order';
 export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render';
-export type { BuilderDataValidated, BuilderErrorVariantInvalid, BuilderErrorComponentMissing, BuilderErrorVariantMissing, BuilderErrorComponentUnexpected, BuilderErrorValidate, BuilderErrorsValidate, BuilderValidateResult } from './validate';
+export type { BuilderDataValidated, BuilderDataError, BuilderDataErrors, BuilderDataErrorComponentMissing, BuilderDataErrorComponentUnexpected, BuilderDataErrorVariantInvalid, BuilderDataErrorVariantMissing, BuilderDataValidateResult } from './validate';
+export type { BuilderModelValidated, BuilderModelValidateError, BuilderModelValidateErrors, BuilderModelValidateErrorInvalidCollection, BuilderModelValidateErrorInvalidOption, BuilderModelValidateOptions, BuilderModelValidateResult } from './instance';
 export type { BuilderDescription, BuilderDescriptionItem } from '../schemas/index';
-export { instance } from './instance.js';
+export { instance, BuilderModelValidateException } from './instance.js';
 export { models } from './models.js';
 export { order } from './order.js';
 export { ordinal, render } from './render.js';
-export { validate } from './validate.js';
+export { validate, BuilderDataValidateError } from './validate.js';

package/dist/resolve/index.js

@@ -1,5 +1,5 @@
-export { instance } from './instance.js';
+export { instance, BuilderModelValidateException } from './instance.js';
 export { models } from './models.js';
 export { order } from './order.js';
 export { ordinal, render } from './render.js';
-export { validate } from './validate.js';
+export { validate, BuilderDataValidateError } from './validate.js';