@builder-builder/builder 0.0.7 → 0.0.8

package/dist/check.d.ts

@@ -2,7 +2,8 @@ import * as v from 'valibot';
 declare class Check {
     truthy<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
     falsy(input: unknown, message?: `${string}! ❌`): void;
-    assert<const TSchema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: TSchema, input: unknown): asserts input is v.InferOutput<TSchema>;
+    is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferInput<Schema>;
+    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): asserts input is v.InferInput<Schema>;
 }
 export declare const check: Check;
 export {};

package/dist/check.js

@@ -1,16 +1,20 @@
 import * as v from 'valibot';
+import { BuilderException } from './exception.js';
 const DEFAULT_MESSAGE = 'Unexpected value! ❌';
 class Check {
     truthy(input, message = DEFAULT_MESSAGE) {
         if (!input) {
-            throw new Error(message);
+            throw new BuilderException([], message);
         }
     }
     falsy(input, message = DEFAULT_MESSAGE) {
         if (input) {
-            throw new Error(message);
+            throw new BuilderException([], message);
         }
     }
+    is(schema, input) {
+        return v.is(schema, input);
+    }
     assert(schema, input) {
         v.assert(schema, input);
     }

package/dist/entities/builder/builder.d.ts

@@ -0,0 +1,494 @@
+import type { Prettify } from '../../prettify';
+import type { BuilderRefs, Refable } from '../../references';
+import type { BuilderCollections } from '../collection/index';
+import type { BuilderComponentDetails, BuilderComponents } from '../component/index';
+import type { BuilderExpectation, BuilderExpectations } from '../expectation';
+import type { BuilderOptions } from '../option/index';
+import type { BuilderWhenConstrained } from '../when';
+import type { BuilderStateAsserted } from './expectation';
+import type { BuilderCollectionMethod, BuilderComponentMethod, BuilderOptionMethod } from './methods';
+import type { BuilderBindings, BuilderBoundState } from './parameter';
+import type { BuilderState, BuilderStateEmpty } from './state';
+import * as v from 'valibot';
+export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
+    #private;
+    readonly type: 'builder';
+    readonly references: State['references'];
+    readonly options: State['options'];
+    readonly components: State['components'];
+    readonly collections: State['collections'];
+    readonly expectations: BuilderExpectations;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(references?: BuilderRefs, options?: BuilderOptions, components?: BuilderComponents, collections?: BuilderCollections, expectations?: BuilderExpectations);
+    get option(): BuilderOptionMethod<State>;
+    get component(): BuilderComponentMethod<State>;
+    get collection(): BuilderCollectionMethod<State>;
+    expect<const Expectations extends readonly [BuilderExpectation, ...ReadonlyArray<BuilderExpectation>]>(...expectations: Expectations): Builder<BuilderStateAsserted<State, Expectations>>;
+    bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings & {
+        readonly [Key in keyof Bindings]: BuilderWhenConstrained<State, Bindings[Key]>;
+    }): Builder<BuilderBoundState<State, Bindings>>;
+}
+export type BuilderGeneric = Builder<BuilderState>;
+export declare const BuilderSchema: v.InstanceSchema<typeof Builder, undefined>;
+export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly references: v.SchemaWithPipe<readonly [v.ArraySchema<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;
+    }>[]>]>;
+    readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"select", undefined>;
+            readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+            readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }, {
+            readonly serialisable: typeof import("..").BuilderSelectType;
+            readonly instance: v.InstanceSchema<typeof import("..").BuilderSelectType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"toggle", undefined>;
+            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+            readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+            readonly isOptional: v.BooleanSchema<undefined>;
+        }, undefined>, v.MetadataAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }, {
+            readonly serialisable: typeof import("..").BuilderToggleType;
+            readonly instance: v.InstanceSchema<typeof import("..").BuilderToggleType, undefined>;
+        }>, v.ReadonlyAction<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>]>], undefined>, v.ReadonlyAction<Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+        }> | Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+        }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+            readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<"select", undefined>;
+                readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+                readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly isOptional: v.BooleanSchema<undefined>;
+                readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.MetadataAction<{
+                type: "select";
+                readonly options: readonly [string, ...string[]];
+                defaultValue: string | null;
+                isOptional: boolean;
+                optionLabels: {
+                    [x: string]: string;
+                };
+            }, {
+                readonly serialisable: typeof import("..").BuilderSelectType;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderSelectType, undefined>;
+            }>, v.ReadonlyAction<{
+                type: "select";
+                readonly options: readonly [string, ...string[]];
+                defaultValue: string | null;
+                isOptional: boolean;
+                optionLabels: {
+                    [x: string]: string;
+                };
+            }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly type: v.LiteralSchema<"toggle", undefined>;
+                readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+                readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+                readonly isOptional: v.BooleanSchema<undefined>;
+            }, undefined>, v.MetadataAction<{
+                type: "toggle";
+                valueType: "string" | "number" | "boolean";
+                defaultValue: string | number | boolean | null;
+                isOptional: boolean;
+            }, {
+                readonly serialisable: typeof import("..").BuilderToggleType;
+                readonly instance: v.InstanceSchema<typeof import("..").BuilderToggleType, undefined>;
+            }>, v.ReadonlyAction<{
+                type: "toggle";
+                valueType: "string" | "number" | "boolean";
+                defaultValue: string | number | boolean | null;
+                isOptional: boolean;
+            }>]>], undefined>, v.ReadonlyAction<Readonly<{
+                type: "select";
+                readonly options: readonly [string, ...string[]];
+                defaultValue: string | null;
+                isOptional: boolean;
+                optionLabels: {
+                    [x: string]: string;
+                };
+            }> | Readonly<{
+                type: "toggle";
+                valueType: "string" | "number" | "boolean";
+                defaultValue: string | number | boolean | null;
+                isOptional: boolean;
+            }>>]>, v.GenericSchema], undefined>;
+        }>]>;
+        readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }>, {
+            readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+        }>]>, undefined>;
+    }, undefined>, v.MetadataAction<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }, {
+        readonly serialisable: typeof import("..").BuilderOption;
+        readonly instance: v.InstanceSchema<typeof import("..").BuilderOption, undefined>;
+    }>, v.ReadonlyAction<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[]>]>;
+    readonly components: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly expectations: v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly name: v.StringSchema<undefined>;
+                readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+            }, undefined>, v.MetadataAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }, {
+                readonly serialisable: typeof BuilderExpectation;
+                readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+            }>, v.ReadonlyAction<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[], {
+                readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                    readonly name: v.StringSchema<undefined>;
+                    readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+                }, undefined>, v.MetadataAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }, {
+                    readonly serialisable: typeof BuilderExpectation;
+                    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+                }>, v.ReadonlyAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[]>]>;
+            }>]>;
+        }, undefined>, v.MetadataAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }, {
+            readonly serialisable: typeof BuilderComponentDetails;
+            readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+        }>, v.ReadonlyAction<{
+            expectations: import("../..").BuilderRef | Readonly<{
+                type: "ref";
+                id: string;
+                name: string;
+            }> | readonly Readonly<{
+                name: string;
+                kind: "option" | "component" | "collection" | "detail";
+            }>[];
+        }>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
+            readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly expectations: v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                    readonly name: v.StringSchema<undefined>;
+                    readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+                }, undefined>, v.MetadataAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }, {
+                    readonly serialisable: typeof BuilderExpectation;
+                    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+                }>, v.ReadonlyAction<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
+                    type: "ref";
+                    id: string;
+                    name: string;
+                }> | readonly Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[], {
+                    readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                        readonly name: v.StringSchema<undefined>;
+                        readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+                    }, undefined>, v.MetadataAction<{
+                        name: string;
+                        kind: "option" | "component" | "collection" | "detail";
+                    }, {
+                        readonly serialisable: typeof BuilderExpectation;
+                        readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+                    }>, v.ReadonlyAction<{
+                        name: string;
+                        kind: "option" | "component" | "collection" | "detail";
+                    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+                        name: string;
+                        kind: "option" | "component" | "collection" | "detail";
+                    }>[]>]>;
+                }>]>;
+            }, undefined>, v.MetadataAction<{
+                expectations: import("../..").BuilderRef | Readonly<{
+                    type: "ref";
+                    id: string;
+                    name: string;
+                }> | readonly Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[];
+            }, {
+                readonly serialisable: typeof BuilderComponentDetails;
+                readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
+            }>, v.ReadonlyAction<{
+                expectations: import("../..").BuilderRef | Readonly<{
+                    type: "ref";
+                    id: string;
+                    name: string;
+                }> | readonly Readonly<{
+                    name: string;
+                    kind: "option" | "component" | "collection" | "detail";
+                }>[];
+            }>]>, v.GenericSchema], undefined>;
+        }>]>;
+        readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[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 import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }>, {
+            readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+        }>]>, undefined>;
+    }, undefined>, v.MetadataAction<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }, {
+        readonly serialisable: typeof import("..").BuilderComponent;
+        readonly instance: v.InstanceSchema<typeof import("..").BuilderComponent, undefined>;
+    }>, v.ReadonlyAction<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[]>]>;
+    readonly collections: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<import("..").BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<import("..").BuilderCollectionSerialised[]>]>;
+    readonly expectations: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
+    }, undefined>, v.MetadataAction<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }, {
+        readonly serialisable: typeof BuilderExpectation;
+        readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
+    }>, v.ReadonlyAction<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[]>]>;
+}, undefined>, v.MetadataAction<{
+    readonly references: readonly Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>[];
+    readonly options: readonly Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[];
+    readonly components: readonly Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[];
+    readonly collections: readonly import("..").BuilderCollectionSerialised[];
+    readonly expectations: readonly Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[];
+}, {
+    readonly serialisable: typeof Builder;
+    readonly instance: v.InstanceSchema<typeof Builder, undefined>;
+}>, v.ReadonlyAction<{
+    readonly references: readonly Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>[];
+    readonly options: readonly Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[];
+    readonly components: readonly Readonly<{
+        name: string;
+        payload: unknown;
+        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+            type: "ref";
+            id: string;
+            name: string;
+        }> | undefined;
+    }>[];
+    readonly collections: readonly import("..").BuilderCollectionSerialised[];
+    readonly expectations: readonly Readonly<{
+        name: string;
+        kind: "option" | "component" | "collection" | "detail";
+    }>[];
+}>]>;
+export type BuilderSerialised = v.InferOutput<typeof BuilderSerialisedSchema>;
+export type BuilderStateOf<Input extends Refable<BuilderGeneric>> = Input extends Builder<infer State extends BuilderState> ? State : BuilderStateEmpty;
+export type BuilderInstanceOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? Prettify<State['model']> : never;
+export type BuilderReference = Refable<BuilderGeneric>;
+export type BuilderReferences = ReadonlyArray<Refable<BuilderGeneric>>;

package/dist/entities/builder/builder.js

@@ -0,0 +1,84 @@
+import * as v from 'valibot';
+import { check } from '../../check.js';
+import { BuilderRefsSerialisedSchema } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { BuilderCollectionsSerialisedSchema } from '../collection/index.js';
+import { BuilderComponentDetailsSchema, BuilderComponentsSerialisedSchema, componentDetails } from '../component/index.js';
+import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { BuilderOptionsSerialisedSchema } from '../option/index.js';
+import { builderCollectionMethod, builderComponentMethod, builderOptionMethod } from './methods.js';
+import { bindBuilder } from './parameter.js';
+import { validateDuplicates, validatePaths } from './validate.js';
+export class Builder {
+    references;
+    options;
+    components;
+    collections;
+    expectations;
+    id = crypto.randomUUID();
+    constructor(references = [], options = [], components = [], collections = [], expectations = []) {
+        this.references = references;
+        this.options = options;
+        this.components = components;
+        this.collections = collections;
+        this.expectations = expectations;
+        validateDuplicates(this);
+        validatePaths(this);
+    }
+    get option() {
+        const method = builderOptionMethod();
+        const add = (name, payload) => {
+            return this.#next({ options: [...this.options, method(name, payload)] });
+        };
+        const when = (gatePaths, name, config) => {
+            return this.#next({ options: [...this.options, method.when(gatePaths, name, config)] });
+        };
+        return Object.assign(add, { when });
+    }
+    get component() {
+        const method = builderComponentMethod();
+        const add = (name, details) => {
+            const wrappedDetails = check.is(BuilderComponentDetailsSchema, details)
+                ? details
+                : details != null
+                    ? componentDetails(details)
+                    : details;
+            return this.#next({ components: [...this.components, method(name, wrappedDetails)] });
+        };
+        const when = (gatePaths, name, config) => {
+            return this.#next({
+                components: [...this.components, method.when(gatePaths, name, config)]
+            });
+        };
+        return Object.assign(add, { when });
+    }
+    get collection() {
+        const method = builderCollectionMethod();
+        const add = (name, payload) => {
+            return this.#next({ collections: [...this.collections, method(name, payload)] });
+        };
+        const when = (gatePaths, name, config) => {
+            return this.#next({
+                collections: [...this.collections, method.when(gatePaths, name, config)]
+            });
+        };
+        return Object.assign(add, { when });
+    }
+    expect(...expectations) {
+        return this.#next({ expectations: [...this.expectations, ...expectations] });
+    }
+    bind(bindings) {
+        return bindBuilder(this, bindings);
+    }
+    #next(patch) {
+        return new Builder(this.references, patch.options ?? this.options, patch.components ?? this.components, patch.collections ?? this.collections, patch.expectations ?? this.expectations);
+    }
+}
+export const BuilderSchema = v.instance(Builder);
+export const BuilderSerialisedSchema = serialisable(Builder, v.object({
+    references: BuilderRefsSerialisedSchema,
+    options: BuilderOptionsSerialisedSchema,
+    components: BuilderComponentsSerialisedSchema,
+    collections: BuilderCollectionsSerialisedSchema,
+    expectations: BuilderExpectationsSerialisedSchema
+}));

package/dist/entities/builder/builders.d.ts

@@ -0,0 +1,20 @@
+import type { BuilderGeneric, BuilderReferences, BuilderStateOf } from './builder';
+import type { BuilderState, BuilderStateEmpty } from './state';
+import { Builder } from './builder.js';
+export declare function builders<const References extends BuilderReferences>(...builders: References): Builder<BuilderBuildersMerge<References>>;
+export declare function mergeBuilderParts(parts: ReadonlyArray<unknown>): {
+    references: import("../..").BuilderRef[];
+    options: import("..").BuilderOption<string, import("../..").Refable<import("..").BuilderOptionPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
+    components: import("..").BuilderComponent<string, import("../..").Refable<import("..").BuilderComponentPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
+    collections: import("..").BuilderCollection<string, import("../..").Refable<import("..").BuilderCollectionPayload>, import("../..").Refable<readonly (readonly (string | number)[])[]>>[];
+    expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
+};
+export type BuilderBuildersMerge<References extends BuilderReferences> = References extends readonly [infer Head, ...infer Tail extends BuilderReferences] ? Head extends BuilderGeneric ? BuilderStateMerge<BuilderStateOf<Head>, BuilderBuildersMerge<Tail>> : BuilderBuildersMerge<Tail> : BuilderStateEmpty;
+type BuilderStateMerge<Left extends BuilderState, Right extends BuilderState> = {
+    model: Left['model'] & Right['model'];
+    references: Left['references'] & Right['references'];
+    options: [...Left['options'], ...Right['options']];
+    components: [...Left['components'], ...Right['components']];
+    collections: [...Left['collections'], ...Right['collections']];
+};
+export {};

package/dist/entities/builder/builders.js

@@ -0,0 +1,18 @@
+import * as v from 'valibot';
+import { isRef } from '../../references.js';
+import { Builder, BuilderSchema } from './builder.js';
+export function builders(...builders) {
+    const references = builders.filter((payload) => isRef(payload));
+    const merged = mergeBuilderParts(builders);
+    return new Builder([...references, ...merged.references], merged.options, merged.components, merged.collections, merged.expectations);
+}
+export function mergeBuilderParts(parts) {
+    const instances = parts.filter((part) => v.is(BuilderSchema, part));
+    return {
+        references: instances.flatMap((builder) => [...builder.references]),
+        options: instances.flatMap((builder) => [...builder.options]),
+        components: instances.flatMap((builder) => [...builder.components]),
+        collections: instances.flatMap((builder) => [...builder.collections]),
+        expectations: instances.flatMap((builder) => [...builder.expectations])
+    };
+}