@builder-builder/builder 0.0.8 → 0.0.10

package/dist/entities/ui/ui.js

@@ -1,53 +1,52 @@
 import * as v from 'valibot';
-import { BuilderRefsSerialisedSchema, isRef, refable } from '../../references.js';
+import { BuilderParametersSerialisedSchema, BuilderReferencesSchema, isParameter, paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderSerialisedSchema } from '../builder/index.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
-import { bindUI } from './parameter.js';
+import { bindUI } from './bind.js';
 import { BuilderUIDescribe } from './describe.js';
-import { BuilderUILabel } from './label.js';
 import { BuilderUIPage } from './page.js';
 import { BuilderUIItemsSerialisedSchema, BuilderUIPages } from './pages.js';
 import { validatePagesCollections } from './validate.js';
 export class BuilderUI {
     builder;
-    references;
+    parameters;
     items;
     expectations;
+    references;
     id = crypto.randomUUID();
-    constructor(builder, references, items, expectations) {
+    constructor(builder, parameters, items, expectations, references = []) {
         this.builder = builder;
-        this.references = references;
+        this.parameters = parameters;
         this.items = items;
         this.expectations = expectations;
+        this.references = references;
         validatePagesCollections(builder, items);
     }
     expect(...expectations) {
-        return new BuilderUI(this.builder, this.references, this.items, [...this.expectations, ...expectations]
+        return new BuilderUI(this.builder, this.parameters, this.items, [...this.expectations, ...expectations], this.references
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
         );
     }
     page(label, paths) {
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPage(this.#label(label), paths)], this.expectations);
+        return new BuilderUI(this.builder, this.parameters, [...this.items, new BuilderUIPage(label, paths)], this.expectations, this.references);
     }
     describe(label, paths) {
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIDescribe(this.#label(label), paths)], this.expectations);
+        return new BuilderUI(this.builder, this.parameters, [...this.items, new BuilderUIDescribe(label, paths)], this.expectations, this.references);
     }
     pages(name, label, itemUI) {
-        const items = isRef(itemUI) ? itemUI : itemUI.items;
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPages(name, this.#label(label), items)], this.expectations);
+        const items = isParameter(itemUI) ? itemUI : itemUI.items;
+        return new BuilderUI(this.builder, this.parameters, [...this.items, new BuilderUIPages(name, label, items)], this.expectations, this.references);
     }
     bind(bindings) {
         return bindUI(this, bindings);
     }
-    #label(label) {
-        return isRef(label) ? label : new BuilderUILabel(label);
-    }
 }
 export const BuilderUISchema = v.instance(BuilderUI);
 export const BuilderUISerialisedSchema = serialisable(BuilderUI, v.object({
-    builder: refable(v.lazy(() => BuilderSerialisedSchema)),
-    references: BuilderRefsSerialisedSchema,
+    builder: paramable(v.lazy(() => BuilderSerialisedSchema)),
+    parameters: BuilderParametersSerialisedSchema,
     items: BuilderUIItemsSerialisedSchema,
-    expectations: BuilderExpectationsSerialisedSchema
+    expectations: BuilderExpectationsSerialisedSchema,
+    references: BuilderReferencesSchema
 }));

package/dist/entities/ui/uis.d.ts

@@ -1,10 +1,16 @@
 import type { BuilderGeneric } from '../builder/index';
-import type { BuilderUIReferences } from './ui';
-import { BuilderRef } from '../../references.js';
+import type { BuilderUIParts } from './ui';
+import type { BuilderUIItems } from './pages';
+import { BuilderParameter } from '../../references.js';
 import { BuilderUI } from './ui.js';
-export declare function uis(): BuilderUI<BuilderRef>;
-export declare function uis<const BuilderType extends BuilderGeneric>(uiBuilder: BuilderType, ...parts: BuilderUIReferences): BuilderUI<BuilderType>;
+export declare function uis(): BuilderUI<BuilderParameter>;
+export declare function uis<const BuilderType extends BuilderGeneric>(uiBuilder: BuilderType, ...parts: BuilderUIParts): BuilderUI<BuilderType>;
 export declare function mergeUIParts(parts: ReadonlyArray<unknown>): {
-    references: BuilderRef[];
+    parameters: BuilderParameter<string>[];
     expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
+    references: Readonly<{
+        parameter: string;
+        id: string;
+    }>[];
 };
+export declare function flattenUIItems(items: ReadonlyArray<unknown>): BuilderUIItems;

package/dist/entities/ui/uis.js

@@ -1,20 +1,19 @@
 import * as v from 'valibot';
-import { BuilderRef } from '../../references.js';
+import { BuilderParameter } from '../../references.js';
 import { BuilderUI, BuilderUISchema } from './ui.js';
 export function uis(uiBuilder, ...parts) {
-    const builder = uiBuilder ?? new BuilderRef('builder');
+    const builder = uiBuilder ?? new BuilderParameter('builder');
     const merged = mergeUIParts(parts);
-    return new BuilderUI(builder, merged.references, parts.flatMap((part) => {
-        if (v.is(BuilderUISchema, part)) {
-            return [...part.items];
-        }
-        return [part];
-    }), merged.expectations);
+    return new BuilderUI(builder, merged.parameters, flattenUIItems(parts), merged.expectations, merged.references);
 }
 export function mergeUIParts(parts) {
     const instances = parts.filter((part) => v.is(BuilderUISchema, part));
     return {
-        references: instances.flatMap((instance) => [...instance.references]),
-        expectations: instances.flatMap((instance) => [...instance.expectations])
+        parameters: instances.flatMap((instance) => [...instance.parameters]),
+        expectations: instances.flatMap((instance) => [...instance.expectations]),
+        references: instances.flatMap((instance) => [...instance.references])
     };
 }
+export function flattenUIItems(items) {
+    return items.flatMap((item) => v.is(BuilderUISchema, item) ? [...item.items] : [item]);
+}

package/dist/entities/ui/validate.d.ts

@@ -1,8 +1,8 @@
-import type { Refable } from '../../references';
+import type { Paramable } from '../../references';
 import type { BuilderGeneric } from '../builder/index';
 import type { BuilderUIItems } from './pages';
 export type BuilderErrorPagesUnknownCollection = {
     readonly kind: 'pages-unknown-collection';
     readonly name: string;
 };
-export declare function validatePagesCollections(builder: Refable<BuilderGeneric>, items: Refable<BuilderUIItems>): void;
+export declare function validatePagesCollections(builder: Paramable<BuilderGeneric>, items: Paramable<BuilderUIItems>): void;

package/dist/entities/ui/validate.js

@@ -1,12 +1,12 @@
 import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
+import { isParameter } from '../../references.js';
 import { BuilderUIPages } from './pages.js';
 export function validatePagesCollections(builder, items) {
-    if (isRef(builder) || isRef(items)) {
+    if (isParameter(builder) || isParameter(items)) {
         return;
     }
     const errors = items.flatMap((item) => {
-        if (isRef(item) || !(item instanceof BuilderUIPages)) {
+        if (isParameter(item) || !(item instanceof BuilderUIPages)) {
             return [];
         }
         const exists = builder.collections.some((entry) => entry.name === item.name);

package/dist/entities/validate.d.ts

@@ -1,11 +1,11 @@
 import type { BuilderExpectation } from './expectation';
-import type { BuilderRef } from '../references';
+import type { BuilderParameter } from '../references';
 import type { Builder, BuilderGeneric } from './builder/index';
 import type { BuilderCollection, BuilderCollectionConfig } from './collection/index';
 import type { BuilderComponent, BuilderComponentDetails } from './component/index';
 import type { BuilderOption, BuilderSelectType, BuilderToggleType } from './option/index';
-import type { BuilderUI, BuilderUIDescribe, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUILabel, BuilderUIPage, BuilderUIPages } from './ui/index';
-export type Strip<T> = T extends BuilderRef ? never : T extends BuilderSelectType | BuilderToggleType | BuilderUILabel | BuilderExpectation ? T : T extends Builder<infer State> ? Builder<Strip<State>> : T extends BuilderOption<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderOption<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderComponent<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderComponent<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollection<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderCollection<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollectionConfig<infer Inner, infer Min, infer Max> ? BuilderCollectionConfig<Strip<Inner>, Strip<Min>, Strip<Max>> : T extends BuilderComponentDetails<infer Expectations> ? BuilderComponentDetails<Strip<Expectations>> : T extends BuilderUI<infer Inner, infer Items> ? BuilderUI<Strip<Inner>, Strip<Items> & BuilderUIItems> : T extends BuilderUIPage<infer Label, infer Paths> ? BuilderUIPage<Strip<Label>, Strip<Paths>> : T extends BuilderUIDescribe<infer Label, infer Paths> ? BuilderUIDescribe<Strip<Label>, Strip<Paths>> : T extends BuilderUIPages<infer Name, infer Label, infer Items> ? BuilderUIPages<Name, Strip<Label>, Strip<Items>> : T extends ReadonlyArray<unknown> ? StripTuple<T> : T extends object ? {
+import type { BuilderUI, BuilderUIDescribe, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIPage, BuilderUIPages } from './ui/index';
+export type Strip<T> = T extends BuilderParameter ? never : T extends BuilderSelectType | BuilderToggleType | BuilderExpectation ? T : T extends Builder<infer State> ? Builder<Strip<State>> : T extends BuilderOption<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderOption<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderComponent<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderComponent<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollection<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderCollection<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollectionConfig<infer Inner, infer Min, infer Max> ? BuilderCollectionConfig<Strip<Inner>, Strip<Min>, Strip<Max>> : T extends BuilderComponentDetails<infer Expectations> ? BuilderComponentDetails<Strip<Expectations>> : T extends BuilderUI<infer Inner, infer Items> ? BuilderUI<Strip<Inner>, Strip<Items> & BuilderUIItems> : T extends BuilderUIPage<infer Label, infer Paths> ? BuilderUIPage<Strip<Label>, Strip<Paths>> : T extends BuilderUIDescribe<infer Label, infer Paths> ? BuilderUIDescribe<Strip<Label>, Strip<Paths>> : T extends BuilderUIPages<infer Name, infer Label, infer Items> ? BuilderUIPages<Name, Strip<Label>, Strip<Items>> : T extends ReadonlyArray<unknown> ? StripTuple<T> : T extends object ? {
     readonly [Key in keyof T]: Strip<T[Key]>;
 } : T;
 type StripEntry<Narrowed, Payload, GatePaths> = [Strip<Payload>] extends [never] ? never : [Strip<GatePaths>] extends [never] ? never : Narrowed;

package/dist/entities/when.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderPath, BuilderPaths } from '../paths';
 import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
-import type { BuilderRef, BuilderRefSerialised, Refable } from '../references';
+import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '../references';
 import type { BuilderGeneric, BuilderState, BuilderStateOf } from './builder/index';
 import * as v from 'valibot';
 export type BuilderEnableConfig<Payload = unknown> = {
@@ -22,16 +22,16 @@ export type BuilderUnlessConfig<Payload = unknown, UnlessPath = BuilderPath> = {
 export type BuilderWhen<Payload = unknown, MatchPath = BuilderPath, MatchSelectMap = Record<string, Payload | null>, UnlessPath = BuilderPath> = BuilderEnableConfig<Payload> | BuilderMatchConfig<Payload, MatchPath, MatchSelectMap> | BuilderUnlessConfig<Payload, UnlessPath>;
 export type WhenSerialised<Payload> = {
     readonly type: 'enable';
-    readonly payload: Payload | BuilderRefSerialised;
+    readonly payload: Payload | BuilderParameterSerialised;
 } | {
     readonly type: 'match';
-    readonly matchPath: BuilderRefSerialised | BuilderPath;
-    readonly selectMap: Record<string, (Payload | BuilderRefSerialised) | null> | BuilderRefSerialised;
+    readonly matchPath: BuilderParameterSerialised | BuilderPath;
+    readonly selectMap: Record<string, (Payload | BuilderParameterSerialised) | null> | BuilderParameterSerialised;
 } | {
     readonly type: 'unless';
-    readonly unlessPath: BuilderRefSerialised | BuilderPath;
+    readonly unlessPath: BuilderParameterSerialised | BuilderPath;
     readonly disabledValues: BuilderPrimitives;
-    readonly payload: Payload | BuilderRefSerialised;
+    readonly payload: Payload | BuilderParameterSerialised;
 };
 export type WhenConfigPayload<Config extends BuilderWhenConfig, Payload> = Config extends {
     readonly payload: infer Inner extends Payload;
@@ -42,37 +42,37 @@ export declare const BuilderWhenEnableSchema: v.ObjectSchema<{
 export declare const BuilderWhenMatchSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
     readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly type: v.LiteralSchema<"parameter", undefined>;
         readonly id: v.StringSchema<undefined>;
         readonly name: v.StringSchema<undefined>;
     }, undefined>, v.ReadonlyAction<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    }>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }> | BuilderParameter<string>, {
+        readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
     }>]>;
 }, undefined>;
 export declare const BuilderWhenUnlessSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"unless", undefined>;
     readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly type: v.LiteralSchema<"parameter", undefined>;
         readonly id: v.StringSchema<undefined>;
         readonly name: v.StringSchema<undefined>;
     }, undefined>, v.ReadonlyAction<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    }>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }> | BuilderParameter<string>, {
+        readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
     }>]>;
 }, undefined>;
 export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
@@ -80,71 +80,72 @@ export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.Varia
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
     readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly type: v.LiteralSchema<"parameter", undefined>;
         readonly id: v.StringSchema<undefined>;
         readonly name: v.StringSchema<undefined>;
     }, undefined>, v.ReadonlyAction<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    }>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }> | BuilderParameter<string>, {
+        readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
     }>]>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"unless", undefined>;
     readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly type: v.LiteralSchema<"parameter", undefined>;
         readonly id: v.StringSchema<undefined>;
         readonly name: v.StringSchema<undefined>;
     }, undefined>, v.ReadonlyAction<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    }>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }> | BuilderParameter<string>, {
+        readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
     }>]>;
 }, undefined>], undefined>, v.ReadonlyAction<{
     type: "enable";
 } | {
     type: "match";
-    matchPath: readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    matchPath: readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>;
+    }> | BuilderParameter<string>;
 } | {
     type: "unless";
-    unlessPath: readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    unlessPath: readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }>;
+    }> | BuilderParameter<string>;
 }>]>;
 export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
+export declare function createSelectMapSerialisedSchema(payloadSchema: v.GenericSchema): v.GenericSchema;
 export declare function createWhenSerialisedSchema(payloadSchema: v.GenericSchema): v.GenericSchema;
 export declare function createWhenFactories<Payload>(): {
-    enable: <const Values extends Refable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends Refable<Payload>, const MatchPath extends Refable<BuilderPath>, const SelectMap extends Refable<BuilderMatchSelectMap<Refable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends Refable<Payload>, const UnlessPath extends Refable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends Paramable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Paramable<Payload>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<Paramable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Paramable<Payload>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
 };
 export type BuilderValidPath<State extends BuilderState> = ModelValidPath<State['model']>;
 export type BuilderValidPaths<State extends BuilderState> = ReadonlyArray<BuilderValidPath<State>>;
-export type BuilderValidPathsOf<Input extends Refable<BuilderGeneric>> = BuilderValidPaths<BuilderStateOf<Input>>;
-export type BuilderWhenConstrained<State extends BuilderState, Config> = Config extends BuilderRef ? Config : Config extends {
+export type BuilderValidPathsOf<Input extends Paramable<BuilderGeneric>> = BuilderValidPaths<BuilderStateOf<Input>>;
+export type BuilderWhenConstrained<State extends BuilderState, Config> = Config extends BuilderParameter ? Config : Config extends {
     readonly type: 'match';
     readonly matchPath: infer MatchPath extends BuilderPath;
     readonly selectMap: infer SelectMap;
 } ? Config & {
     readonly matchPath: [MatchPath] extends [Readonly<BuilderValidPath<State>>] ? MatchPath : Readonly<BuilderValidPath<State>>;
-    readonly selectMap: SelectMap extends BuilderRef ? SelectMap : Record<BuilderResolvePath<State['model'], MatchPath> & string, SelectMap[keyof SelectMap]>;
+    readonly selectMap: SelectMap extends BuilderParameter ? SelectMap : Record<BuilderResolvePath<State['model'], MatchPath> & string, SelectMap[keyof SelectMap]>;
 } : Config extends {
     readonly type: 'unless';
     readonly unlessPath: infer UnlessPath extends BuilderPath;
@@ -157,14 +158,14 @@ export type WhenConfigNullable<Config extends BuilderWhenConfig> = Config extend
     readonly type: 'match';
     readonly selectMap: infer SelectMap;
 } ? null extends SelectMap[keyof SelectMap] ? null : never : never;
-export type WhenNullability<State extends BuilderState, GatePaths extends Refable<BuilderPaths>, Config extends Refable<BuilderWhenConfig>> = [GatePaths] extends [BuilderRef] ? null : WhenNullabilityFromPaths<State['model'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
+export type WhenNullability<State extends BuilderState, GatePaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenConfig>> = [GatePaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['model'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
 type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Model & string
 ] ? Model[Head] : Path extends readonly [
     infer Head extends keyof Model & string,
     ...infer Tail extends BuilderPath
 ] ? Model[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Model[Head], Tail> : never;
-type WhenNullabilityFromPaths<Model, GatePaths extends BuilderPaths, Config extends Refable<BuilderWhenConfig>> = Config extends BuilderRef ? WhenPathsNullable<Model, GatePaths> : Config extends BuilderWhenConfig ? WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config> : never;
+type WhenNullabilityFromPaths<Model, GatePaths extends BuilderPaths, Config extends Paramable<BuilderWhenConfig>> = Config extends BuilderParameter ? WhenPathsNullable<Model, GatePaths> : Config extends BuilderWhenConfig ? WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config> : never;
 type WhenPathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
     infer Head extends BuilderPath,
     ...infer Tail extends BuilderPaths

package/dist/entities/when.js

@@ -1,34 +1,37 @@
 import * as v from 'valibot';
 import { BuilderPathSchema } from '../paths.js';
 import { BuilderPrimitivesSchema } from '../primitive.js';
-import { refable } from '../references.js';
+import { paramable } from '../references.js';
 export const BuilderWhenEnableSchema = v.object({
     type: v.literal('enable')
 });
 export const BuilderWhenMatchSchema = v.object({
     type: v.literal('match'),
-    matchPath: refable(BuilderPathSchema)
+    matchPath: paramable(BuilderPathSchema)
 });
 export const BuilderWhenUnlessSchema = v.object({
     type: v.literal('unless'),
-    unlessPath: refable(BuilderPathSchema)
+    unlessPath: paramable(BuilderPathSchema)
 });
 export const BuilderWhenConfigSchema = v.pipe(v.variant('type', [BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema]), v.readonly());
+export function createSelectMapSerialisedSchema(payloadSchema) {
+    return v.pipe(v.record(v.string(), v.nullable(paramable(payloadSchema))), v.readonly());
+}
 export function createWhenSerialisedSchema(payloadSchema) {
-    const refablePayload = refable(payloadSchema);
+    const paramablePayload = paramable(payloadSchema);
     return v.pipe(v.variant('type', [
         v.object({
             ...BuilderWhenEnableSchema.entries,
-            payload: refablePayload
+            payload: paramablePayload
         }),
         v.object({
             ...BuilderWhenMatchSchema.entries,
-            selectMap: refable(v.record(v.string(), v.nullable(refablePayload)))
+            selectMap: paramable(createSelectMapSerialisedSchema(payloadSchema))
         }),
         v.object({
             ...BuilderWhenUnlessSchema.entries,
             disabledValues: BuilderPrimitivesSchema,
-            payload: refablePayload
+            payload: paramablePayload
         })
     ]), v.readonly());
 }

package/dist/index.d.ts

@@ -1,22 +1,23 @@
-export type { Builder, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderGeneric, BuilderInstanceOf, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderReference, BuilderReferences, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUILabel, BuilderUILabelSerialised, BuilderUIPage, BuilderUIPageSerialised, BuilderUIPages, BuilderUIPagesSerialised, BuilderUIReference, BuilderUIReferences, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderWhenConfig } from './entities/index';
+export type { Builder, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderGeneric, BuilderInstanceOf, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPart, BuilderParts, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIPart, BuilderUIParts, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderWhenConfig } from './entities/index';
+export type { BuilderEntity, BuilderEntityKind } from './entities/index';
 export type { BuilderError, BuilderErrors } from './exception';
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderOrder, BuilderRefEntities, BuilderRefEntity, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
 export type { BuilderData, BuilderModel, BuilderModelInput, BuilderModels, BuilderVariant, BuilderVariants } from './model';
 export type { BuilderPath, BuilderPaths } from './paths';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
-export type { BuilderRef, BuilderRefSerialised, Refable, RefableSerialised } from './references';
+export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, BuilderReference, BuilderReferences, Paramable, ParamableSerialised } from './references';
 import { builders, collectionConfig, collectionExpectation, componentDetails, componentExpectation, detailExpectation, optionExpectation, uis } from './entities/index.js';
 import { createInstance, createModels } from './mappers/index.js';
 export declare const builder: typeof builders;
 export declare const collection: typeof collectionConfig & {
-    enable: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import(".").BuilderGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import(".").BuilderGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./entities/when").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import(".").BuilderGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import(".").BuilderGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const component: typeof componentDetails & {
-    enable: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(payload?: Payload) => import("./entities/when").BuilderEnableConfig<Payload>;
-    match: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>, const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./entities/when").BuilderUnlessConfig<Payload, UnlessPath>;
+    enable: <const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>>(payload?: Payload) => import("./entities/when").BuilderEnableConfig<Payload>;
+    match: <const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./entities/when").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>, const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./entities/when").BuilderUnlessConfig<Payload, UnlessPath>;
 };
 export declare const has: {
     collection: typeof collectionExpectation;
@@ -27,11 +28,15 @@ export declare const has: {
 export declare const instance: typeof createInstance;
 export declare const models: typeof createModels;
 export declare const option: {
-    enable: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./entities/when").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const ui: typeof uis;
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderExpectationsSerialisedSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSerialisedSchema, BuilderUISerialisedSchema, deserialise, entitiesByKind, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
 export { BuilderException } from './exception.js';
-export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { order, ordinal, render } from './mappers/index.js';
+export { BuilderEntityKindSchema, BuilderEntitySchema } from './entities/index.js';
+export { order, ordinal, refs, render } from './mappers/index.js';
+export { BuilderVariantsSchema } from './model.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';
+export { isSerialisedParameter } from './references.js';

package/dist/index.js

@@ -17,6 +17,10 @@ export const instance = createInstance;
 export const models = createModels;
 export const option = optionWhen;
 export const ui = uis;
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderExpectationsSerialisedSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSerialisedSchema, BuilderUISerialisedSchema, deserialise, entitiesByKind, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
 export { BuilderException } from './exception.js';
-export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { order, ordinal, render } from './mappers/index.js';
+export { BuilderEntityKindSchema, BuilderEntitySchema } from './entities/index.js';
+export { order, ordinal, refs, render } from './mappers/index.js';
+export { BuilderVariantsSchema } from './model.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';
+export { isSerialisedParameter } from './references.js';

package/dist/mappers/assert/builder.js

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { BuilderCollectionConfigSchema, BuilderSerialisedSchema } from '../../entities/index.js';
 import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
+import { isParameter } from '../../references.js';
 import { createWalkerValidation } from '../../walker/index.js';
 import { collectExpectationErrors } from './expectation.js';
 export function assertBuilder(builder) {
@@ -12,35 +12,35 @@ export function assertBuilder(builder) {
 }
 function collectBuilderErrors(builder) {
     const expectationErrors = collectNestedBuilders(builder).flatMap((inner) => collectExpectationErrors(inner, inner.expectations));
-    const parameterErrors = [];
-    const walkValidate = createWalkerValidation((ref) => {
-        parameterErrors.push({ kind: 'unbound-parameter', name: ref.name });
+    const parameterWalkErrors = [];
+    const walkValidate = createWalkerValidation((parameter) => {
+        parameterWalkErrors.push({ kind: 'unbound-parameter', name: parameter.name });
     });
     walkValidate(BuilderSerialisedSchema, builder);
-    const referenceErrors = builder.references
-        .filter(isRef)
-        .map((reference) => ({ kind: 'unbound-parameter', name: reference.name }));
-    return [...expectationErrors, ...referenceErrors, ...parameterErrors];
+    const parameterErrors = builder.parameters
+        .filter(isParameter)
+        .map((parameter) => ({ kind: 'unbound-parameter', name: parameter.name }));
+    return [...expectationErrors, ...parameterErrors, ...parameterWalkErrors];
 }
 function collectNestedBuilders(builder) {
     const nested = builder.collections.flatMap((collection) => nestedBuildersOf(collection.payload));
     return [builder, ...nested.flatMap((inner) => collectNestedBuilders(inner))];
 }
 function nestedBuildersOf(payload) {
-    if (isRef(payload)) {
+    if (isParameter(payload)) {
         return [];
     }
     if (v.is(BuilderCollectionConfigSchema, payload)) {
-        return isRef(payload.builder) ? [] : [payload.builder];
+        return isParameter(payload.builder) ? [] : [payload.builder];
     }
     const whenPayload = payload;
     if (whenPayload.type === 'match' && whenPayload.selectMap != null) {
-        return Object.values(whenPayload.selectMap).flatMap((value) => value && !isRef(value.builder) ? [value.builder] : []);
+        return Object.values(whenPayload.selectMap).flatMap((value) => value && !isParameter(value.builder) ? [value.builder] : []);
     }
     const inner = whenPayload.payload;
-    if (inner == null || isRef(inner)) {
+    if (inner == null || isParameter(inner)) {
         return [];
     }
     const innerBuilder = inner.builder;
-    return isRef(innerBuilder) ? [] : [innerBuilder];
+    return isParameter(innerBuilder) ? [] : [innerBuilder];
 }

package/dist/mappers/assert/ui.js

@@ -1,6 +1,6 @@
 import { BuilderUISerialisedSchema } from '../../entities/index.js';
 import { BuilderException } from '../../exception.js';
-import { isRef } from '../../references.js';
+import { isParameter } from '../../references.js';
 import { createWalkerValidation } from '../../walker/index.js';
 import { collectExpectationErrors } from './expectation.js';
 export function assertUI(ui) {
@@ -11,11 +11,11 @@ export function assertUI(ui) {
 }
 function collectUIErrors(ui) {
     const parameterErrors = [];
-    const walkValidate = createWalkerValidation((ref) => {
-        parameterErrors.push({ kind: 'unbound-parameter', name: ref.name });
+    const walkValidate = createWalkerValidation((parameter) => {
+        parameterErrors.push({ kind: 'unbound-parameter', name: parameter.name });
     });
     walkValidate(BuilderUISerialisedSchema, ui);
-    const expectationErrors = isRef(ui.builder)
+    const expectationErrors = isParameter(ui.builder)
         ? []
         : collectExpectationErrors(ui.builder, ui.expectations);
     return [...parameterErrors, ...expectationErrors];

package/dist/mappers/index.d.ts

@@ -1,7 +1,9 @@
 export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './assert/index';
 export type { BuilderOrder } from './order/index';
+export type { BuilderRefEntities, BuilderRefEntity } from './refs';
 export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './render/index';
 export { createInstance } from './instance/index.js';
 export { createModels } from './models/index.js';
 export { order } from './order/index.js';
+export { refs } from './refs.js';
 export { ordinal, render } from './render/index.js';