@builder-builder/builder 0.0.4 → 0.0.6

package/dist/core/builder.d.ts

@@ -1,63 +1,70 @@
+import type { Prettify } from '../prettify';
 import type { BuilderCollectionEntries, BuilderCollectionMethod } from './collection/index';
 import type { BuilderComponentEntries, BuilderComponentMethod } from './component/index';
-import type { BuilderOptionEntries, BuilderOptionMethod, BuilderOptionValues, BuilderSelectType } from './option/index';
+import type { BuilderOptionEntries, BuilderOptionMethod } from './option/index';
 import type { BuilderBindings, BuilderBoundState } from './parameter';
+import type { BuilderExpectationEntries, BuilderExpectations, ComponentAssert, ModelAssert } from './expectation';
 import { BuilderComponentGraph } from './component/index.js';
 import { BuilderOptionGraph } from './option/index.js';
-export type BuilderSelectMap<Select extends BuilderSelectType = BuilderSelectType> = Record<Select['options'][number], BuilderOptionValues | null>;
-export type BuilderSelectMapGeneric = BuilderSelectMap<any>;
 export type BuilderState = {
     readonly model: unknown;
     readonly options: BuilderOptionEntries;
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
+    readonly expectations: BuilderExpectationEntries;
 };
 export type BuilderStateEmpty = {
     readonly model: unknown;
     readonly options: [];
     readonly components: [];
     readonly collections: [];
+    readonly expectations: [];
 };
-import type { Prettify } from '../prettify';
 export type BuilderStateMerge<State extends BuilderState, Patch extends Partial<BuilderState>> = {
-    model: 'model' extends keyof Patch ? Patch['model'] : State['model'];
-    options: 'options' extends keyof Patch ? Patch['options'] : State['options'];
-    components: 'components' extends keyof Patch ? Patch['components'] : State['components'];
-    collections: 'collections' extends keyof Patch ? Patch['collections'] : State['collections'];
+    model: Prettify<'model' extends keyof Patch ? Patch['model'] : State['model']>;
+    options: Extract<'options' extends keyof Patch ? Patch['options'] : State['options'], BuilderOptionEntries>;
+    components: Extract<'components' extends keyof Patch ? Patch['components'] : State['components'], BuilderComponentEntries>;
+    collections: Extract<'collections' extends keyof Patch ? Patch['collections'] : State['collections'], BuilderCollectionEntries>;
+    expectations: Extract<'expectations' extends keyof Patch ? Patch['expectations'] : State['expectations'], BuilderExpectationEntries>;
 };
+export type BuilderMerge<State extends BuilderState, Patch extends Partial<BuilderState>> = Builder<BuilderStateMerge<State, Patch>>;
 export type BuilderGeneric = Builder<any>;
-export type BuilderFactory = (builder: BuilderGeneric) => BuilderGeneric;
-export type BuilderPart = BuilderGeneric | BuilderFactory;
-export type BuilderParts = ReadonlyArray<BuilderPart>;
+export type Builders = ReadonlyArray<BuilderGeneric>;
 export type BuilderStateOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? State : BuilderStateEmpty;
 export type BuilderModelOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? Prettify<State['model']> : never;
-export type BuilderCollectionsOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? State['collections'] : never;
 export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     #private;
     readonly _options: State['options'];
     readonly _components: State['components'];
     readonly _collections: State['collections'];
+    readonly _expectations: State['expectations'];
     readonly options: BuilderOptionEntries;
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
-    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries);
+    readonly expectations: BuilderExpectationEntries;
+    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries, expectations?: BuilderExpectationEntries);
     get optionGraph(): BuilderOptionGraph;
     get componentGraph(): BuilderComponentGraph;
     get option(): BuilderOptionMethod<State>;
     get component(): BuilderComponentMethod<State>;
     get collection(): BuilderCollectionMethod<State>;
+    expect<const Expectations extends BuilderExpectations>(...expectations: Expectations): BuilderMerge<State, {
+        model: ModelAssert<Builder<State>, Expectations>;
+        components: ComponentAssert<Builder<State>, Expectations>;
+        expectations: [...State['expectations'], ...Expectations];
+    }>;
     bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
 }
-export declare function builder<const Parts extends BuilderParts>(...parts: Parts): Builder<MergedPartsState<Parts>>;
-type ExtractPartState<Part> = Part extends BuilderGeneric ? BuilderStateOf<Part> : Part extends (...args: ReadonlyArray<any>) => infer Result ? Result extends BuilderGeneric ? BuilderStateOf<Result> : BuilderStateEmpty : BuilderStateEmpty;
-type MergedPartsState<Parts extends ReadonlyArray<BuilderPart>> = Parts extends readonly [
-    infer Head,
-    ...infer Tail extends ReadonlyArray<BuilderPart>
-] ? MergeStates<ExtractPartState<Head>, MergedPartsState<Tail>> : BuilderStateEmpty;
-type MergeStates<Left extends BuilderState, Right extends BuilderState> = {
+export declare function builder<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+type MergedPartsState<Parts extends ReadonlyArray<BuilderGeneric>> = Parts extends readonly [
+    infer Head extends BuilderGeneric,
+    ...infer Tail extends ReadonlyArray<BuilderGeneric>
+] ? MergedStates<BuilderStateOf<Head>, MergedPartsState<Tail>> : BuilderStateEmpty;
+type MergedStates<Left extends BuilderState, Right extends BuilderState> = {
     model: Left['model'] & Right['model'];
     options: [...Left['options'], ...Right['options']];
     components: [...Left['components'], ...Right['components']];
     collections: [...Left['collections'], ...Right['collections']];
+    expectations: [...Left['expectations'], ...Right['expectations']];
 };
 export {};

package/dist/core/builder.js

@@ -1,20 +1,22 @@
-import { bindOptions } from './parameter.js';
 import * as v from 'valibot';
+import { BuilderExpectation } from './expectation.js';
 import { check } from '../check.js';
 import { BuilderCollection, resolveCollectionNames } from './collection/index.js';
 import { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 import { BuilderOption, BuilderOptionGraph } from './option/index.js';
-import { BuilderParameter } from './parameter.js';
+import { BuilderParameter, bindOptions, extractValues } from './parameter.js';
 export class Builder {
     options;
     components;
     collections;
+    expectations;
     #optionGraph = null;
     #componentGraph = null;
-    constructor(options = [], collections = [], components = []) {
+    constructor(options = [], collections = [], components = [], expectations = []) {
         this.options = options;
         this.collections = collections;
         this.components = components;
+        this.expectations = expectations;
     }
     get optionGraph() {
         if (this.#optionGraph === null) {
@@ -33,16 +35,22 @@ 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);
         };
         const addConditionalOption = (gatePaths, name, config) => {
-            const values = v.is(v.instance(BuilderParameter), config) ? config : config.values;
-            const optionConfig = v.is(v.instance(BuilderParameter), config) ? null : config;
-            const entry = new BuilderOption(name, values, gatePaths, optionConfig);
+            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);
+            }
+            const entry = new BuilderOption(name, extractValues(config), gatePaths, config);
             return this.#next([...this.options, entry], this.collections, this.components);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addOption, { when: addConditionalOption });
     }
     get component() {
@@ -57,6 +65,7 @@ export class Builder {
             const entry = new BuilderComponent(name, paths, dependencies);
             return this.#next(this.options, this.collections, [...this.components, entry]);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addComponent, { when: addConditionalComponent });
     }
     get collection() {
@@ -76,21 +85,40 @@ export class Builder {
             const entry = new BuilderCollection(name, defaultEntry.builder, defaultEntry.min, defaultEntry.max, gatePaths, config);
             return this.#next(this.options, [...this.collections, entry], this.components);
         };
+        // 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, [
+            ...this.expectations,
+            ...expectations
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
+        ]);
+    }
     bind(bindings) {
         const boundOptions = bindOptions(this.options, bindings);
-        return new Builder(boundOptions, this.collections, this.components);
+        return new Builder(boundOptions, this.collections, this.components, this.expectations);
     }
     #next(options, collections, components) {
-        return new Builder(options, collections, components);
+        return new Builder(options, collections, components, this.expectations);
     }
 }
-export function builder(...parts) {
-    const instances = parts.filter((part) => part instanceof Builder);
-    const base = new Builder(instances.flatMap((instance) => instance.options), instances.flatMap((instance) => instance.collections), instances.flatMap((instance) => instance.components));
-    const factories = parts.filter((part) => !(part instanceof Builder));
-    return factories.reduce((accumulated, factory) => {
-        return factory(accumulated);
-    }, base);
+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);
+            }
+            else if (expectation.kind === 'collection') {
+                expectation.validate(merged.collections);
+            }
+        }
+    });
+    return merged;
 }

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

@@ -1,22 +1,20 @@
-import type { BuilderModel, BuilderModels } from '../../config';
+import type { BuilderModel, BuilderModels } from '../../model';
 import type { BuilderPaths } from '../../paths';
+import type { BuilderGeneric, BuilderModelOf, BuilderStateOf } from '../builder';
 import type { BuilderCollectionWhenConfig } from './method';
-import type { BuilderGeneric, BuilderStateOf } from '../builder';
 export type BuilderCollectionConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = {
     readonly builder: CollectionRecipe;
     readonly min: Min;
     readonly max: Max;
 };
 export type BuilderCollectionEntries = ReadonlyArray<BuilderCollection>;
-export type BuilderTupleOf<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : BuilderTupleOf<Item, Length, [...Result, Item]>;
-export type BuilderCollectionOf<Builder extends BuilderGeneric, Name extends string> = FindCollection<BuilderStateOf<Builder>['collections'], Name>;
-type FindCollection<Config extends BuilderCollectionEntries, Name extends string> = Config extends readonly [infer Head, ...infer Tail extends BuilderCollectionEntries] ? Extract<Head, BuilderCollection<Name, any, any, any>> extends never ? FindCollection<Tail, Name> : Extract<Head, BuilderCollection<Name, any, any, any>> : Extract<Config[number], BuilderCollection<Name, any, any, any>>;
-export type BuilderCollectionNamesOf<Builder extends BuilderGeneric> = ExtractCollectionNames<BuilderStateOf<Builder>['collections']>;
-type ExtractCollectionNames<Entries extends BuilderCollectionEntries> = Entries extends readonly [
-    infer Head extends BuilderCollection,
-    ...infer Tail extends BuilderCollectionEntries
-] ? Head['name'] | ExtractCollectionNames<Tail> : never;
-export type BuilderCollectionModelOf<CollectionRecipe, Min extends number, Max extends number> = number extends Min ? ReadonlyArray<ExtractModel<CollectionRecipe>> : number extends Max ? ReadonlyArray<ExtractModel<CollectionRecipe>> : Min extends Max ? BuilderTupleOf<ExtractModel<CollectionRecipe>, Min> : ReadonlyArray<ExtractModel<CollectionRecipe>>;
+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 | 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;
     readonly builder: CollectionRecipe;
@@ -29,5 +27,6 @@ export declare class BuilderCollection<const Name extends string = string, const
 }
 export declare function resolveCollectionNames(collections: BuilderCollectionEntries): Set<string>;
 export declare function resolveCollectionModels(model: BuilderModel, collectionName: string): BuilderModels;
-type ExtractModel<Input> = Input extends BuilderGeneric ? BuilderStateOf<Input>['model'] : unknown;
+type CollectionOf<Config extends BuilderCollectionEntries, Name extends string> = Config extends readonly [infer Head, ...infer Tail extends BuilderCollectionEntries] ? Extract<Head, BuilderCollection<Name, any, any, any>> extends never ? CollectionOf<Tail, Name> : Extract<Head, BuilderCollection<Name, any, any, any>> : Extract<Config[number], BuilderCollection<Name, any, any, any>>;
+type CollectionNamesOf<Entries extends BuilderCollectionEntries> = Entries[number]['name'];
 export {};

package/dist/core/collection/collection.js

@@ -1,5 +1,5 @@
 import { check } from '../../check.js';
-import { readPath } from '../../paths.js';
+import { resolve } from '../when/index.js';
 export class BuilderCollection {
     name;
     builder;
@@ -19,28 +19,10 @@ export class BuilderCollection {
         this.config = config;
     }
     resolve(model) {
-        if (this.config === null) {
-            return this;
-        }
-        if (!this.gatePaths.every((path) => !!readPath(model, path))) {
-            return null;
-        }
-        switch (this.config.type) {
-            case 'enable': {
-                return this;
-            }
-            case 'match': {
-                const matchPath = this.config.matchPath;
-                const entry = this.config.selectMap[String(readPath(model, matchPath))];
-                return entry ? new BuilderCollection(this.name, entry.builder, entry.min, entry.max) : null;
-            }
-            case 'unless': {
-                const value = readPath(model, this.config.unlessPath);
-                return !this.config.disabledValues.includes(value)
-                    ? this
-                    : null;
-            }
-        }
+        return resolve(this, model, (selectMap, matchValue) => {
+            const entry = selectMap[matchValue];
+            return entry ? new BuilderCollection(this.name, entry.builder, entry.min, entry.max) : null;
+        });
     }
 }
 export function resolveCollectionNames(collections) {

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

@@ -1,4 +1,4 @@
-export type { BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderTupleOf } from './collection';
+export type { BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, TupleOf, CollectionShape } from './collection';
 export type { BuilderCollectionEnableConfig, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './method';
 export { BuilderCollection, resolveCollectionModels, resolveCollectionNames } from './collection.js';
 export { collection } from './method.js';

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

@@ -1,51 +1,30 @@
-import type { BuilderPrimitive } from '../../config';
-import type { BuilderPath, BuilderPaths, BuilderResolvePath, BuilderValidPath } from '../../paths';
-import type { BuilderStateMerge, BuilderGeneric, BuilderState } from '../builder';
-import type { Builder } from '../builder';
+import type { BuilderPrimitive } from '../../model';
+import type { BuilderPath, BuilderValidPaths } from '../../paths';
+import type { BuilderGeneric, BuilderMerge, BuilderState } from '../builder';
+import type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig, WhenConfigConstrained, WhenNullability } from '../when/index';
 import type { BuilderCollection, BuilderCollectionConfig, BuilderCollectionModelOf } from './collection';
-export type BuilderCollectionEnableConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = {
-    readonly type: 'enable';
-    readonly builder: CollectionRecipe;
-    readonly min: Min;
-    readonly max: Max;
-};
-export type BuilderCollectionMatchConfig<SelectMap extends Record<string, BuilderCollectionConfig | null> = Record<string, BuilderCollectionConfig | null>, MatchPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'match';
-    readonly matchPath: MatchPath;
-    readonly selectMap: SelectMap;
-};
-export type BuilderCollectionUnlessConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number, UnlessPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'unless';
-    readonly unlessPath: UnlessPath;
-    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
-    readonly builder: CollectionRecipe;
-    readonly min: Min;
-    readonly max: Max;
-};
+export type BuilderCollectionEnableConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = BuilderWhenEnableConfig<BuilderCollectionConfig<CollectionRecipe, Min, Max>>;
+export type BuilderCollectionMatchConfig<SelectMap extends Record<string, BuilderCollectionConfig | null> = Record<string, BuilderCollectionConfig | null>, MatchPath extends BuilderPath = BuilderPath> = BuilderWhenMatchConfig<SelectMap, MatchPath>;
+export type BuilderCollectionUnlessConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number, UnlessPath extends BuilderPath = BuilderPath> = BuilderWhenUnlessConfig<BuilderCollectionConfig<CollectionRecipe, Min, Max>, UnlessPath>;
 export type BuilderCollectionWhenConfig = BuilderCollectionEnableConfig | BuilderCollectionMatchConfig | BuilderCollectionUnlessConfig;
-export declare const collection: {
-    enable: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionEnableConfig<CollectionRecipe, Min, Max>;
-    match: <const MatchPath extends BuilderPath, const SelectMap extends Record<string, BuilderCollectionConfig | null>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderCollectionMatchConfig<SelectMap, MatchPath>;
-    unless: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionUnlessConfig<CollectionRecipe, Min, Max, UnlessPath>;
-};
-type CollectionWhenConfigModel<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? BuilderCollectionModelOf<(NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['builder'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['min'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['max']> : never;
-type CollectionWhenConfigResolver<Name extends string, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? BuilderCollection<Name, (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['builder'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['min'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['max']> : never;
-type CollectionConfigNullable<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionUnlessConfig ? null : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? null extends SelectMapType[keyof SelectMapType] ? null : never : never;
-type CollectionGatePathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [infer Head extends BuilderPath, ...infer Tail extends BuilderPaths] ? null extends BuilderResolvePath<Model, Head> ? null : CollectionGatePathsNullable<Model, Tail> : never;
-type CollectionWhenNullability<Model, GatePaths extends BuilderPaths, Config extends BuilderCollectionWhenConfig> = CollectionGatePathsNullable<Model, GatePaths> | CollectionConfigNullable<Config>;
-type CollectionWhenConfigConstrained<Model, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionMatchConfig ? Config & {
-    readonly matchPath: Readonly<BuilderValidPath<Model>>;
-} : Config extends BuilderCollectionUnlessConfig ? Config & {
-    readonly unlessPath: Readonly<BuilderValidPath<Model>>;
-} : Config;
 export type BuilderCollectionMethod<State extends BuilderState> = {
-    <const Name extends string, const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(name: Name, collectionRecipe: CollectionRecipe, min?: Min, max?: Max): Builder<BuilderStateMerge<State, {
+    <const Name extends string, const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(name: Name, collectionRecipe: CollectionRecipe, min?: Min, max?: Max): BuilderMerge<State, {
         model: State['model'] & Record<Name, BuilderCollectionModelOf<CollectionRecipe, Min, Max>>;
         collections: [...State['collections'], BuilderCollection<Name, CollectionRecipe, Min, Max>];
-    }>>;
-    when: <const GatePaths extends ReadonlyArray<BuilderValidPath<State['model']>>, const Name extends string, const Config extends BuilderCollectionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & CollectionWhenConfigConstrained<State['model'], Config>) => Builder<BuilderStateMerge<State, {
-        model: State['model'] & Record<Name, CollectionWhenConfigModel<Config> | CollectionWhenNullability<State['model'], GatePaths, Config>>;
+    }>;
+    when: <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string, const Config extends BuilderCollectionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & WhenConfigConstrained<State['model'], Config>) => BuilderMerge<State, {
+        model: State['model'] & Record<Name, CollectionWhenConfigModel<Config> | WhenNullability<State['model'], GatePaths, Config>>;
         collections: [...State['collections'], CollectionWhenConfigResolver<Name, Config>];
-    }>>;
+    }>;
+};
+export declare const collection: {
+    enable: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionEnableConfig<CollectionRecipe, Min, Max>;
+    match: <const MatchPath extends BuilderPath, const SelectMap extends Record<string, BuilderCollectionConfig | null>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderCollectionMatchConfig<SelectMap, MatchPath>;
+    unless: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionUnlessConfig<CollectionRecipe, Min, Max, UnlessPath>;
 };
+type SelectMapEntryOf<SelectMap> = NonNullable<SelectMap[keyof SelectMap]> & BuilderCollectionConfig;
+type CollectionModelOfConfig<Config extends BuilderCollectionConfig> = BuilderCollectionModelOf<Config['builder'], Config['min'], Config['max']>;
+type CollectionOfConfig<Name extends string, Config extends BuilderCollectionConfig> = BuilderCollection<Name, Config['builder'], Config['min'], Config['max']>;
+type CollectionWhenConfigModel<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput extends BuilderGeneric, infer Min extends number, infer Max extends number> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput extends BuilderGeneric, infer Min extends number, infer Max extends number> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? CollectionModelOfConfig<SelectMapEntryOf<SelectMapType>> : never;
+type CollectionWhenConfigResolver<Name extends string, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min extends number, infer Max extends number> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min extends number, infer Max extends number> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? CollectionOfConfig<Name, SelectMapEntryOf<SelectMapType>> : never;
 export {};

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

@@ -1,14 +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 extends readonly [
-    ...infer Init extends BuilderComponentEntries,
-    BuilderComponent<infer Name>
-] ? Name | BuilderComponentNamesOf<Init> : never;
+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

@@ -1,21 +1,21 @@
 import { check } from '../../check.js';
+import { crossProduct } from '../graph.js';
 import { BuilderComponent } from './component.js';
-const EMPTY_MODEL = '{}';
 export class BuilderComponentGraph {
     paths;
     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))
@@ -27,7 +27,7 @@ export class BuilderComponentGraph {
                 Array.from(graphPath.keys).every((key) => handledKeys.has(key));
             if (!isHandled) {
                 const componentModels = this.#createModels(graphPath, keys);
-                models = models.flatMap((model) => componentModels.map((pathModel) => ({ ...model, ...pathModel })));
+                models = crossProduct(models, componentModels);
                 handledKeys.add(graphPath.name);
                 graphPath.keys.forEach((key) => handledKeys.add(key));
             }
@@ -48,3 +48,4 @@ export class BuilderComponentGraph {
         return models;
     }
 }
+const EMPTY_MODEL = '{}';

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/component/method.d.ts

@@ -1,13 +1,11 @@
-import type { BuilderValidPath } from '../../paths';
-import type { BuilderComponentNamesOf } from './component';
-import type { BuilderStateMerge, BuilderState } from '../builder';
-import type { Builder } from '../builder';
-import type { BuilderComponent } from './component';
+import type { BuilderValidPaths } from '../../paths';
+import type { BuilderMerge, BuilderState } from '../builder';
+import type { BuilderComponent, BuilderComponentNamesOf } from './component';
 export type BuilderComponentMethod<State extends BuilderState> = {
-    <const Name extends string>(name: Name, paths: ReadonlyArray<BuilderValidPath<State['model']>>): Builder<BuilderStateMerge<State, {
+    <const Name extends string>(name: Name, paths: BuilderValidPaths<State['model']>): BuilderMerge<State, {
         components: [...State['components'], BuilderComponent<Name>];
-    }>>;
-    when: <const Name extends string>(dependencies: ReadonlyArray<BuilderComponentNamesOf<State['components']>>, name: Name, paths: ReadonlyArray<BuilderValidPath<State['model']>>) => Builder<BuilderStateMerge<State, {
+    }>;
+    when: <const Name extends string>(dependencies: ReadonlyArray<BuilderComponentNamesOf<State['components']>>, name: Name, paths: BuilderValidPaths<State['model']>) => BuilderMerge<State, {
         components: [...State['components'], BuilderComponent<Name>];
-    }>>;
+    }>;
 };

package/dist/core/expectation.d.ts

@@ -0,0 +1,45 @@
+import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
+import type { Prettify } from '../prettify';
+import { BuilderCollection } from './collection/index.js';
+import { BuilderComponent } from './component/index.js';
+export type BuilderExpectationKind = 'option' | 'component' | 'collection';
+export type BuilderExpectationEntries = ReadonlyArray<BuilderExpectation>;
+export type BuilderExpectations = readonly [
+    BuilderExpectation,
+    ...ReadonlyArray<BuilderExpectation>
+];
+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 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: Kind;
+    constructor(name: Name, kind: Kind);
+    optional(): BuilderExpectation<Name, Value | null, Kind>;
+    validate(entries: ReadonlyArray<{
+        readonly name: string;
+    }>): void;
+}
+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, 'option'> ? Record<Name, Value> : 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, 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/{assert → core}/expectation.js

@@ -1,3 +1,5 @@
+import { BuilderCollection } from './collection/index.js';
+import { BuilderComponent } from './component/index.js';
 import { check } from '../check.js';
 export class BuilderExpectation {
     name;
@@ -13,9 +15,8 @@ export class BuilderExpectation {
         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/graph.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderModels } from '../config';
+import type { BuilderModels } from '../model';
 export type GraphKeys = ReadonlySet<string>;
 export type GraphPath = {
     name: string;
@@ -6,3 +6,4 @@ export type GraphPath = {
     models: BuilderModels;
 };
 export type GraphPaths = ReadonlyArray<GraphPath>;
+export declare function crossProduct(left: BuilderModels, right: BuilderModels): BuilderModels;

package/dist/core/graph.js

@@ -1 +1,3 @@
-export {};
+export function crossProduct(left, right) {
+    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+}

package/dist/core/index.d.ts

@@ -1,9 +1,12 @@
-export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig, BuilderTupleOf } from './collection/index';
-export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentMethod, BuilderComponentNamesOf } from './component/index';
-export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionGraphs, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionValuesMap, BuilderOptionWhenConfig, BuilderSelectTypeGeneric, BuilderSelectTypeLabels, BuilderSelectTypeValues, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option/index';
-export type { BuilderStateMerge, BuilderFactory, BuilderGeneric, BuilderModelOf, BuilderPart, BuilderParts, BuilderState, BuilderStateEmpty, BuilderStateOf, BuilderSelectMap, BuilderSelectMapGeneric } from './builder';
+export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './collection/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 { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
+export { BuilderExpectation, has } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
-export { Builder, builder } from './builder.js';
-export { BuilderParameter } from './parameter.js';
+export { BuilderParameter, BuilderParameterSchema } from './parameter.js';

package/dist/core/index.js

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