@builder-builder/builder 0.0.9 → 0.0.10

package/dist/entities/builder/builder.js

@@ -1,27 +1,29 @@
 import * as v from 'valibot';
 import { check } from '../../check.js';
-import { BuilderRefsSerialisedSchema } from '../../references.js';
+import { BuilderParametersSerialisedSchema, BuilderReferencesSchema } 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 { bindBuilder } from './bind.js';
 import { validateDuplicates, validatePaths } from './validate.js';
 export class Builder {
-    references;
+    parameters;
     options;
     components;
     collections;
     expectations;
+    references;
     id = crypto.randomUUID();
-    constructor(references = [], options = [], components = [], collections = [], expectations = []) {
-        this.references = references;
+    constructor(parameters = [], options = [], components = [], collections = [], expectations = [], references = []) {
+        this.parameters = parameters;
         this.options = options;
         this.components = components;
         this.collections = collections;
         this.expectations = expectations;
+        this.references = references;
         validateDuplicates(this);
         validatePaths(this);
     }
@@ -71,14 +73,15 @@ export class Builder {
         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);
+        return new Builder(this.parameters, patch.options ?? this.options, patch.components ?? this.components, patch.collections ?? this.collections, patch.expectations ?? this.expectations, this.references);
     }
 }
 export const BuilderSchema = v.instance(Builder);
 export const BuilderSerialisedSchema = serialisable(Builder, v.object({
-    references: BuilderRefsSerialisedSchema,
+    parameters: BuilderParametersSerialisedSchema,
     options: BuilderOptionsSerialisedSchema,
     components: BuilderComponentsSerialisedSchema,
     collections: BuilderCollectionsSerialisedSchema,
-    expectations: BuilderExpectationsSerialisedSchema
+    expectations: BuilderExpectationsSerialisedSchema,
+    references: BuilderReferencesSchema
 }));

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

@@ -1,20 +1,35 @@
-import type { BuilderGeneric, BuilderReferences, BuilderStateOf } from './builder';
+import type { BuilderParameter } from '../../references';
+import type { BuilderGeneric, BuilderParts, 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 builders<const Parts extends BuilderParts>(...builders: Parts): Builder<BuilderBuildersMerge<Parts>>;
 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)[])[]>>[];
+    parameters: BuilderParameter<string>[];
+    options: import("..").BuilderOption<string, import("../..").Paramable<import("..").BuilderOptionPayload>, import("../..").Paramable<readonly (readonly (string | number)[])[]>>[];
+    components: import("..").BuilderComponent<string, import("../..").Paramable<import("..").BuilderComponentPayload>, import("../..").Paramable<readonly (readonly (string | number)[])[]>>[];
+    collections: import("..").BuilderCollection<string, import("../..").Paramable<import("..").BuilderCollectionPayload>, import("../..").Paramable<readonly (readonly (string | number)[])[]>>[];
     expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
+    references: Readonly<{
+        parameter: string;
+        id: string;
+    }>[];
 };
-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;
+export type BuilderBuildersMerge<Parts extends BuilderParts> = Parts extends readonly [
+    infer Head,
+    ...infer Tail extends BuilderParts
+] ? Head extends BuilderGeneric ? BuilderStateMerge<BuilderStateOf<Head>, BuilderBuildersMerge<Tail>> : Head extends BuilderParameter ? BuilderStateAppendParameter<Head, BuilderBuildersMerge<Tail>> : BuilderBuildersMerge<Tail> : BuilderStateEmpty;
 type BuilderStateMerge<Left extends BuilderState, Right extends BuilderState> = {
     model: Left['model'] & Right['model'];
-    references: Left['references'] & Right['references'];
+    parameters: readonly [...Left['parameters'], ...Right['parameters']];
     options: [...Left['options'], ...Right['options']];
     components: [...Left['components'], ...Right['components']];
     collections: [...Left['collections'], ...Right['collections']];
 };
+type BuilderStateAppendParameter<Parameter extends BuilderParameter, State extends BuilderState> = {
+    model: State['model'];
+    parameters: readonly [Parameter, ...State['parameters']];
+    options: State['options'];
+    components: State['components'];
+    collections: State['collections'];
+};
 export {};

package/dist/entities/builder/builders.js

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

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

@@ -1,7 +1,7 @@
-export type { BuilderGeneric, BuilderInstanceOf, BuilderReference, BuilderReferences, BuilderSerialised, BuilderStateOf } from './builder';
+export type { BuilderGeneric, BuilderInstanceOf, BuilderPart, BuilderParts, BuilderSerialised, BuilderStateOf } from './builder';
 export type { BuilderStateAsserted, ModelAsserted, ModelExpected } from './expectation';
-export type { BindingModelType, BuilderBindings, BuilderBoundState } from './parameter';
+export type { BindingModelType, BuilderBindings, BuilderBoundState } from './bind';
 export type { BuilderState, BuilderStateAppend, BuilderStateEmpty } from './state';
 export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
 export { builders, mergeBuilderParts } from './builders.js';
-export { bindBuilder } from './parameter.js';
+export { bindBuilder } from './bind.js';

package/dist/entities/builder/index.js

@@ -1,3 +1,3 @@
 export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
 export { builders, mergeBuilderParts } from './builders.js';
-export { bindBuilder } from './parameter.js';
+export { bindBuilder } from './bind.js';

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

@@ -1,5 +1,5 @@
 import type { BuilderPaths } from '../../paths';
-import type { BuilderRef, Refable } from '../../references';
+import type { BuilderParameter, Paramable } from '../../references';
 import type { WhenConfigPayload } from '../when';
 import type { BuilderCollectionConfig, BuilderCollectionWhen } from '../collection/index';
 import type { BuilderComponentDetails, BuilderComponentWhen } from '../component/index';
@@ -11,20 +11,20 @@ import { BuilderCollection } from '../collection/index.js';
 import { BuilderComponent } from '../component/index.js';
 import { BuilderOption } from '../option/index.js';
 export type BuilderOptionMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderOptionValues>>(name: Name, payload: Payload): OptionStateAppend<State, BuilderOption<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderOptionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => OptionStateAppend<State, OptionWhenResolver<Name, Payload>, OptionModelOf<OptionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
+    <const Name extends string, const Payload extends Paramable<BuilderOptionValues>>(name: Name, payload: Payload): OptionStateAppend<State, BuilderOption<Name, Payload>>;
+    when: <const GatePaths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderOptionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => OptionStateAppend<State, OptionWhenResolver<Name, Payload>, OptionModelOf<OptionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
 };
 export type BuilderComponentMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderComponentDetails>>(name: Name, payload?: Payload): ComponentStateAppend<State, BuilderComponent<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderComponentWhen>>(gatePaths: GatePaths, name: Name, payload?: Payload & BuilderWhenConstrained<State, Payload>) => ComponentStateAppend<State, ComponentWhenResolver<Name, Payload>>;
+    <const Name extends string, const Payload extends Paramable<BuilderComponentDetails>>(name: Name, payload?: Payload): ComponentStateAppend<State, BuilderComponent<Name, Payload>>;
+    when: <const GatePaths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderComponentWhen>>(gatePaths: GatePaths, name: Name, payload?: Payload & BuilderWhenConstrained<State, Payload>) => ComponentStateAppend<State, ComponentWhenResolver<Name, Payload>>;
 };
 export type BuilderCollectionMethod<State extends BuilderState> = {
-    <const Name extends string, const Payload extends Refable<BuilderCollectionConfig>>(name: Name, payload: Payload): CollectionStateAppend<State, BuilderCollection<Name, Payload>>;
-    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderCollectionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => CollectionStateAppend<State, CollectionWhenResolver<Name, Payload>, CollectionModelOf<CollectionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
+    <const Name extends string, const Payload extends Paramable<BuilderCollectionConfig>>(name: Name, payload: Payload): CollectionStateAppend<State, BuilderCollection<Name, Payload>>;
+    when: <const GatePaths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderCollectionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => CollectionStateAppend<State, CollectionWhenResolver<Name, Payload>, CollectionModelOf<CollectionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
 };
-type OptionWhenResolver<Name extends string, Payload extends Refable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionValues>> : BuilderOption<Name, BuilderRef>;
-type ComponentWhenResolver<Name extends string, Payload extends Refable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentDetails>> : BuilderComponent<Name, BuilderRef>;
-type CollectionWhenResolver<Name extends string, Payload extends Refable<BuilderCollectionWhen>> = Payload extends BuilderCollectionWhen ? BuilderCollection<Name, WhenConfigPayload<Payload, BuilderCollectionConfig>> : BuilderCollection<Name, BuilderRef>;
+type OptionWhenResolver<Name extends string, Payload extends Paramable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionValues>> : BuilderOption<Name, BuilderParameter>;
+type ComponentWhenResolver<Name extends string, Payload extends Paramable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentDetails>> : BuilderComponent<Name, BuilderParameter>;
+type CollectionWhenResolver<Name extends string, Payload extends Paramable<BuilderCollectionWhen>> = Payload extends BuilderCollectionWhen ? BuilderCollection<Name, WhenConfigPayload<Payload, BuilderCollectionConfig>> : BuilderCollection<Name, BuilderParameter>;
 type OptionStateAppend<State extends BuilderState, Option extends BuilderOption, ModelType = OptionModelOf<Option>> = Builder<BuilderStateAppend<State, {
     model: State['model'] & {
         [K in Option['name']]: ModelType;
@@ -38,7 +38,7 @@ type CollectionStateAppend<State extends BuilderState, Collection extends Builde
     model: State['model'] & Record<Collection['name'], ModelType>;
     collections: [...State['collections'], Collection];
 }>>;
-type OptionModelOf<Option extends BuilderOption> = Option['payload'] extends BuilderRef ? string : Option['payload'] extends {
+type OptionModelOf<Option extends BuilderOption> = Option['payload'] extends BuilderParameter ? string : Option['payload'] extends {
     readonly value: infer Value;
 } ? Value : never;
 type CollectionModelOf<Collection extends BuilderCollection> = [Collection['payload']] extends [
@@ -46,13 +46,13 @@ type CollectionModelOf<Collection extends BuilderCollection> = [Collection['payl
 ] ? null : Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['builder'] extends Builder<infer State extends BuilderState> ? CollectionShape<Collection, State['model']> : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
 type CollectionShape<Collection extends BuilderCollection, Item> = Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['min'] extends number ? Collection['payload']['max'] extends number ? number extends Collection['payload']['min'] ? ReadonlyArray<Item> : number extends Collection['payload']['max'] ? ReadonlyArray<Item> : Collection['payload']['min'] extends Collection['payload']['max'] ? CollectionTuple<Item, Collection['payload']['min']> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item>;
 type CollectionTuple<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : CollectionTuple<Item, Length, [...Result, Item]>;
-export declare function builderOptionMethod(): ((name: string, payload: Refable<BuilderOptionValues>) => BuilderOption<string, Refable<import("..").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderOptionWhen>): BuilderOption<string, Refable<BuilderOptionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+export declare function builderOptionMethod(): ((name: string, payload: Paramable<BuilderOptionValues>) => BuilderOption<string, Paramable<import("..").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderOptionWhen>): BuilderOption<string, Paramable<BuilderOptionWhen>, readonly (readonly (string | number)[])[] | BuilderParameter<string>>;
 };
-export declare function builderComponentMethod(): ((name: string, payload?: Refable<BuilderComponentDetails>) => BuilderComponent<string, Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>> | import("../when").BuilderEnableConfig<Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload?: Refable<BuilderComponentWhen>): BuilderComponent<string, Refable<BuilderComponentWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+export declare function builderComponentMethod(): ((name: string, payload?: Paramable<BuilderComponentDetails>) => BuilderComponent<string, Paramable<BuilderComponentDetails<Paramable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>> | import("../when").BuilderEnableConfig<Paramable<BuilderComponentDetails<Paramable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Paramable<BuilderPaths>, name: string, payload?: Paramable<BuilderComponentWhen>): BuilderComponent<string, Paramable<BuilderComponentWhen>, readonly (readonly (string | number)[])[] | BuilderParameter<string>>;
 };
-export declare function builderCollectionMethod(): ((name: string, payload: Refable<BuilderCollectionConfig>) => BuilderCollection<string, Refable<BuilderCollectionConfig<Refable<import("./builder").BuilderGeneric>, Refable<number>, Refable<number>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
-    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderCollectionWhen>): BuilderCollection<string, Refable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+export declare function builderCollectionMethod(): ((name: string, payload: Paramable<BuilderCollectionConfig>) => BuilderCollection<string, Paramable<BuilderCollectionConfig<Paramable<import("./builder").BuilderGeneric>, Paramable<number>, Paramable<number>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderCollectionWhen>): BuilderCollection<string, Paramable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | BuilderParameter<string>>;
 };
 export {};

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

@@ -1,25 +1,25 @@
 import type { Prettify } from '../../prettify';
-import type { BuilderRefs } from '../../references';
+import type { BuilderParameters } from '../../references';
 import type { BuilderCollections } from '../collection/index';
 import type { BuilderComponents } from '../component/index';
 import type { BuilderOptions } from '../option/index';
 export type BuilderState = {
     model: unknown;
-    references: BuilderRefs;
+    parameters: BuilderParameters;
     options: BuilderOptions;
     components: BuilderComponents;
     collections: BuilderCollections;
 };
 export type BuilderStateEmpty = {
     readonly model: unknown;
-    readonly references: [];
+    readonly parameters: [];
     readonly options: [];
     readonly components: [];
     readonly collections: [];
 };
 export type BuilderStateAppend<State extends BuilderState, Patch extends Partial<BuilderState>> = {
     model: Prettify<'model' extends keyof Patch ? Patch['model'] : State['model']>;
-    references: 'references' extends keyof Patch ? Extract<Patch['references'], BuilderRefs> : State['references'];
+    parameters: 'parameters' extends keyof Patch ? Extract<Patch['parameters'], BuilderParameters> : State['parameters'];
     options: Extract<'options' extends keyof Patch ? Patch['options'] : State['options'], BuilderOptions>;
     components: Extract<'components' extends keyof Patch ? Patch['components'] : State['components'], BuilderComponents>;
     collections: Extract<'collections' extends keyof Patch ? Patch['collections'] : State['collections'], BuilderCollections>;

package/dist/entities/builder/validate.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
+import { isParameter } from '../../references.js';
 import { BuilderCollectionConfigSchema } from '../collection/index.js';
 import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../when.js';
 export function validateDuplicates(builder) {
@@ -37,7 +37,7 @@ function collectPathErrors(builder) {
     return allEntries.flatMap((entry) => pathsForEntry(entry).flatMap((path) => collectEntryPathErrors(builder, entry.name, path)));
 }
 function pathsForEntry(entry) {
-    const gatePaths = entry.gatePaths != null && !isRef(entry.gatePaths)
+    const gatePaths = entry.gatePaths != null && !isParameter(entry.gatePaths)
         ? entry.gatePaths
         : [];
     const configPaths = pathsFromWhen(entry.payload);
@@ -46,11 +46,11 @@ function pathsForEntry(entry) {
 function pathsFromWhen(payload) {
     if (v.is(BuilderWhenMatchSchema, payload)) {
         const matchPath = payload.matchPath;
-        return isRef(matchPath) ? [] : [matchPath];
+        return isParameter(matchPath) ? [] : [matchPath];
     }
     if (v.is(BuilderWhenUnlessSchema, payload)) {
         const unlessPath = payload.unlessPath;
-        return isRef(unlessPath) ? [] : [unlessPath];
+        return isParameter(unlessPath) ? [] : [unlessPath];
     }
     return [];
 }
@@ -88,14 +88,14 @@ function descendCollection(builder, collectionName, index) {
         return [];
     }
     const configs = possibleConfigs(collection.payload);
-    const withinBounds = configs.filter((config) => isRef(config.max) || index < config.max);
+    const withinBounds = configs.filter((config) => isParameter(config.max) || index < config.max);
     if (withinBounds.length === 0 && configs.length > 0) {
         return null;
     }
-    return withinBounds.flatMap((config) => (isRef(config.builder) ? [] : [config.builder]));
+    return withinBounds.flatMap((config) => (isParameter(config.builder) ? [] : [config.builder]));
 }
 function possibleConfigs(payload) {
-    if (isRef(payload)) {
+    if (isParameter(payload)) {
         return [];
     }
     if (v.is(BuilderCollectionConfigSchema, payload)) {

package/dist/entities/collection/collection.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderPaths } from '../../paths';
-import type { Refable, RefableSerialised } from '../../references';
+import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderState } from '../builder/index';
 import type { BuilderWhen, WhenSerialised } from '../when';
 import type { BuilderCollectionConfigSerialised } from './config';
@@ -11,8 +11,8 @@ export type BuilderErrorInvalidCollectionBounds = {
     readonly min: number;
     readonly max: number;
 };
-export type BuilderCollectionPayload = BuilderCollectionConfig | BuilderWhen<Refable<BuilderCollectionConfig>>;
-export declare class BuilderCollection<const Name extends string = string, const Payload extends Refable<BuilderCollectionPayload> = Refable<BuilderCollectionPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+export type BuilderCollectionPayload = BuilderCollectionConfig | BuilderWhen<Paramable<BuilderCollectionConfig>>;
+export declare class BuilderCollection<const Name extends string = string, const Payload extends Paramable<BuilderCollectionPayload> = Paramable<BuilderCollectionPayload>, const GatePaths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'collection';
     readonly name: Name;
     readonly payload: Payload;
@@ -23,10 +23,11 @@ export declare const BuilderCollectionSchema: v.InstanceSchema<typeof BuilderCol
 export type BuilderCollections = ReadonlyArray<BuilderCollection>;
 export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema;
 export type BuilderCollectionWhenSerialised = WhenSerialised<BuilderCollectionConfigSerialised>;
+export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema;
 export type BuilderCollectionSerialised = {
     readonly name: string;
-    readonly gatePaths?: RefableSerialised<BuilderPaths>;
-    readonly payload: RefableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
+    readonly gatePaths?: ParamableSerialised<BuilderPaths>;
+    readonly payload: ParamableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
 };
 export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
 export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;

package/dist/entities/collection/collection.js

@@ -1,9 +1,9 @@
 import * as v from 'valibot';
 import { BuilderException } from '../../exception.js';
 import { BuilderPathsSchema } from '../../paths.js';
-import { isRef, refable } from '../../references.js';
+import { isParameter, paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
-import { createWhenSerialisedSchema } from '../when.js';
+import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderCollectionConfig, BuilderCollectionConfigSerialisedSchema } from './config.js';
 export class BuilderCollection {
     name;
@@ -21,7 +21,7 @@ function validateCollectionBounds(name, payload) {
         return;
     }
     const { min, max } = payload;
-    if (isRef(min) || isRef(max)) {
+    if (isParameter(min) || isParameter(max)) {
         return;
     }
     const minValue = min;
@@ -34,9 +34,10 @@ function validateCollectionBounds(name, payload) {
 }
 export const BuilderCollectionSchema = v.instance(BuilderCollection);
 export const BuilderCollectionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
+export const BuilderCollectionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
 export const BuilderCollectionSerialisedSchema = serialisable(BuilderCollection, v.object({
     name: v.string(),
-    payload: refable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
-    gatePaths: v.optional(refable(BuilderPathsSchema))
+    payload: paramable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
+    gatePaths: v.optional(paramable(BuilderPathsSchema))
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());