@builder-builder/builder 0.0.24 → 0.0.26

package/dist/mappers/price.js

@@ -1,8 +1,7 @@
-import * as v from 'valibot';
 import { BuilderPricingExpressionSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderComponentVariantSchema } from '../instance.js';
-const NumberSchema = v.number();
+import { NumberSchema } from '../primitive.js';
 export function price(pricingInput, order) {
     const { rates, formula } = pricingInput;
     if (formula == null) {
@@ -91,7 +90,7 @@ function reduceValues(values, mode) {
     if (mode === 'sum') {
         return values.reduce((accumulator, value) => accumulator + value, 0);
     }
-    check.truthy(values.length > 0, 'Pricing: cannot reduce empty set with "first"! ❌');
+    check.invariant(values.length > 0);
     const [first] = values;
     return first;
 }

package/dist/mappers/render/collection.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderPath, BuilderReferences, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+export type BuilderRenderCollectionAddRemove = (instance: BuilderInstance) => BuilderInstance;
+export type BuilderRenderCollection = Readonly<{
+    add?: BuilderRenderCollectionAddRemove;
+    remove?: BuilderRenderCollectionAddRemove;
+}>;
+export type BuilderRenderCollections = Readonly<Record<string, BuilderRenderCollection>>;
+export declare function renderCollection(itemsPath: BuilderPath, index: number, min: number, max: number, length: number, builder: BuilderValidated, references: BuilderReferences): BuilderRenderCollection;

package/dist/mappers/render/collection.js

@@ -0,0 +1,27 @@
+import { createInstance } from '../instance.js';
+import { readPath, writePath } from './paths.js';
+export function renderCollection(itemsPath, index, min, max, length, builder, references) {
+    let handlers = {};
+    if (length < max) {
+        handlers = {
+            ...handlers,
+            add: (updateInstance) => {
+                const current = (readPath(updateInstance, itemsPath) ?? []);
+                const clone = current[index] ?? {};
+                const next = [...current.slice(0, index + 1), clone, ...current.slice(index + 1)];
+                return createInstance(builder, writePath(updateInstance, itemsPath, next), references);
+            }
+        };
+    }
+    if (length > min) {
+        handlers = {
+            ...handlers,
+            remove: (updateInstance) => {
+                const current = (readPath(updateInstance, itemsPath) ?? []);
+                const next = [...current.slice(0, index), ...current.slice(index + 1)];
+                return createInstance(builder, writePath(updateInstance, itemsPath, next), references);
+            }
+        };
+    }
+    return handlers;
+}

package/dist/mappers/render/compose.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderReferences } from '../../entities/index';
+import type { BuilderRenderMetadata } from './option';
+export declare function composeLabel(label: unknown, labels: ReadonlyArray<string>, references: BuilderReferences): string;
+export declare function composeString(value: unknown, references: BuilderReferences): string;
+export declare function composeMetadata(value: unknown, references: BuilderReferences): BuilderRenderMetadata;

package/dist/mappers/render/compose.js

@@ -0,0 +1,15 @@
+import { resolveReference } from '../resolve.js';
+import { StringSchema } from '../../primitive.js';
+import { BuilderRenderMetadataSchema } from './option.js';
+export function composeLabel(label, labels, references) {
+    return [...labels, composeString(label, references)]
+        .filter((segment) => segment !== '')
+        .join(', ');
+}
+export function composeString(value, references) {
+    return resolveReference(value, references, StringSchema);
+}
+export function composeMetadata(value, references) {
+    const resolved = resolveReference(value, references, BuilderRenderMetadataSchema);
+    return Object.fromEntries(Object.entries(resolved).map(([key, entry]) => [key, resolveReference(entry, references)]));
+}

package/dist/mappers/render/description.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderDescriptionItem, BuilderModelValidated, BuilderReferences, BuilderUIDescribeValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+export declare function renderDescription(describe: BuilderUIDescribeValidated, label: string, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderDescriptionItem | null;

package/dist/mappers/render/description.js

@@ -0,0 +1,17 @@
+import { check } from '../../errors/index.js';
+import { BuilderPrimitiveSchema } from '../../primitive.js';
+import { resolvePath } from '../resolve.js';
+export function renderDescription(describe, label, model, instance, references) {
+    const values = describe.inputs.flatMap((input) => {
+        const found = resolvePath(model, instance, input.path, references);
+        if (found?.value == null) {
+            return [];
+        }
+        check.assert(BuilderPrimitiveSchema, found.value);
+        return [found.value];
+    });
+    if (values.length === 0) {
+        return null;
+    }
+    return [label, values.join(' ')];
+}

package/dist/mappers/render/index.d.ts

@@ -1,4 +1,6 @@
-export type { BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderUpdate } from './pages';
+export type { BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections } from './collection';
+export type { BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptionUpdate, BuilderRenderOptions } from './option';
+export type { BuilderRenderPage, BuilderRenderPages } from './page';
 export type { BuilderRenderResult } from './render';
 export { render } from './render.js';
 export { ordinal } from './ordinal.js';

package/dist/mappers/render/option.d.ts

@@ -0,0 +1,20 @@
+import type { BuilderModelValidated, BuilderOptionConfigSerialised, BuilderPath, BuilderReferences, BuilderUIInputValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+import type { BuilderPrimitive } from '../../primitive';
+import * as v from 'valibot';
+export type BuilderRenderOptionUpdate = (instance: BuilderInstance, primitive: BuilderPrimitive) => BuilderInstance;
+export declare const BuilderRenderMetadataSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, v.UnknownSchema, undefined>, v.ReadonlyAction<{
+    [x: string]: unknown;
+}>]>;
+export type BuilderRenderMetadata = v.InferOutput<typeof BuilderRenderMetadataSchema>;
+export type BuilderRenderOption = Readonly<{
+    name: string;
+    value: BuilderPrimitive;
+    update: BuilderRenderOptionUpdate;
+    option: BuilderOptionConfigSerialised;
+    displayName?: string;
+    kind?: string;
+    metadata?: BuilderRenderMetadata;
+}>;
+export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
+export declare function renderOption(input: BuilderUIInputValidated, path: BuilderPath, builder: BuilderValidated, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderRenderOption | null;

package/dist/mappers/render/option.js

@@ -0,0 +1,25 @@
+import * as v from 'valibot';
+import { check } from '../../errors/index.js';
+import { BuilderPrimitiveSchema, NameSchema } from '../../primitive.js';
+import { createInstance } from '../instance.js';
+import { resolvePath } from '../resolve.js';
+import { composeMetadata, composeString } from './compose.js';
+import { writePath } from './paths.js';
+export const BuilderRenderMetadataSchema = v.pipe(v.record(NameSchema, v.unknown()), v.readonly());
+export function renderOption(input, path, builder, model, instance, references) {
+    const found = resolvePath(model, instance, input.path, references);
+    if (found == null) {
+        return null;
+    }
+    const fullPath = [...path, ...input.path];
+    check.assert(BuilderPrimitiveSchema, found.value);
+    return {
+        name: found.name,
+        option: found.payload,
+        value: found.value,
+        update: (updateInstance, updateValue) => createInstance(builder, writePath(updateInstance, fullPath, updateValue), references),
+        displayName: input.displayName && composeString(input.displayName, references),
+        kind: input.kind && composeString(input.kind, references),
+        metadata: input.metadata && composeMetadata(input.metadata, references)
+    };
+}

package/dist/mappers/render/page.d.ts

@@ -0,0 +1,11 @@
+import type { BuilderModelValidated, BuilderPath, BuilderReferences, BuilderUIPageValidated, BuilderValidated } from '../../entities/index';
+import type { BuilderInstance } from '../../instance';
+import type { BuilderRenderCollections } from './collection';
+import type { BuilderRenderOptions } from './option';
+export type BuilderRenderPage = Readonly<{
+    label: string;
+    options: BuilderRenderOptions;
+    collections: BuilderRenderCollections;
+}>;
+export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;
+export declare function renderPage(page: BuilderUIPageValidated, label: string, path: BuilderPath, collections: BuilderRenderCollections, builder: BuilderValidated, model: BuilderModelValidated, instance: BuilderInstance, references: BuilderReferences): BuilderRenderPage | null;

package/dist/mappers/render/page.js

@@ -0,0 +1,11 @@
+import { renderOption } from './option.js';
+export function renderPage(page, label, path, collections, builder, model, instance, references) {
+    const options = page.inputs.flatMap((input) => {
+        const option = renderOption(input, path, builder, model, instance, references);
+        return option == null ? [] : [option];
+    });
+    if (options.length === 0) {
+        return null;
+    }
+    return { label, options, collections };
+}

package/dist/mappers/render/paths.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderPath } from '../../entities/index';
+export declare function readPath(container: unknown, path: BuilderPath): unknown;
+export declare function writePath(container: unknown, path: BuilderPath, value: unknown): unknown;

package/dist/mappers/render/paths.js

@@ -0,0 +1,21 @@
+import { check } from '../../errors/index.js';
+import { NumberSchema } from '../../primitive.js';
+export function readPath(container, path) {
+    return path.reduce((current, segment) => current == null ? undefined : current[segment], container);
+}
+export function writePath(container, path, value) {
+    if (path.length === 0) {
+        return value;
+    }
+    const [head, ...tail] = path;
+    if (check.is(NumberSchema, head)) {
+        const next = Array.isArray(container) ? [...container] : [];
+        next[head] = writePath(next[head], tail, value);
+        return next;
+    }
+    const next = container != null && !Array.isArray(container)
+        ? { ...container }
+        : {};
+    next[head] = writePath(next[head], tail, value);
+    return next;
+}

package/dist/mappers/render/render.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderDescription, BuilderInstanceValidated, BuilderReferences, BuilderValidated } from '../../entities/index';
-import type { BuilderRenderPages } from './pages';
+import type { BuilderRenderPages } from './page';
 export type BuilderRenderResult = Readonly<{
     layout: BuilderRenderPages;
     description: BuilderDescription;

package/dist/mappers/render/render.js

@@ -1,120 +1,55 @@
-import * as v from 'valibot';
 import { check } from '../../errors/index.js';
 import { BuilderInstancesSchema } from '../../instance.js';
-import { BuilderPrimitiveSchema } from '../../primitive.js';
-import { createInstance } from '../instance.js';
-import { resolveCollection, resolvePath, resolveReference } from '../resolve.js';
+import { resolveCollection } from '../resolve.js';
+import { renderCollection } from './collection.js';
+import { composeLabel, composeString } from './compose.js';
+import { renderDescription } from './description.js';
 import { ordinal } from './ordinal.js';
-import { BuilderRenderMetadataSchema } from './pages.js';
+import { renderPage } from './page.js';
 export function render(builder, instance, references = []) {
     const layout = [];
     const description = [];
-    walkTree(builder.ui);
+    renderUITree(builder.ui);
     return { layout, description };
-    function walkTree(ui) {
-        ui.uis.forEach((nested) => walkTree(nested));
-        walkItems(ui.items, builder.model, [], [], instance);
+    function renderUITree(ui) {
+        ui.uis.forEach(renderUITree);
+        renderUIItems(ui.items, builder.model, instance, [], [], {});
     }
-    function walkItems(items, model, collectionPath, labelContext, currentInstance) {
+    function renderUIItems(items, model, instance, labels, path, collections) {
         items.forEach((item) => {
             if (item.type === 'page') {
-                emitPage(item, model, collectionPath, labelContext, currentInstance);
+                const page = renderPage(item, composeLabel(item.label, labels, references), path, collections, builder, model, instance, references);
+                if (page != null) {
+                    layout.push(page);
+                }
                 return;
             }
             if (item.type === 'describe') {
-                emitDescribe(item, model, labelContext, currentInstance);
+                const descriptionItem = renderDescription(item, composeLabel(item.label, labels, references), model, instance, references);
+                if (descriptionItem != null) {
+                    description.push(descriptionItem);
+                }
                 return;
             }
-            const collection = findCollection(model, currentInstance, item.name);
+            const definition = model.collections.find((candidate) => candidate.name === item.name);
+            if (definition == null) {
+                return;
+            }
+            const collection = resolveCollection(definition, model, instance, references);
             if (collection == null) {
                 return;
             }
-            const itemInstances = currentInstance[item.name];
-            check.assert(BuilderInstancesSchema, itemInstances, 'Collection field is not an array! ❌');
-            const mergedItemModel = collection.model;
-            itemInstances.forEach((itemInstance, index) => {
-                walkItems(item.items, mergedItemModel, [...collectionPath, item.name, index], [...labelContext, `${ordinal(index)} ${composeLabel(item.label)}`], itemInstance);
+            const instances = instance[item.name];
+            check.assert(BuilderInstancesSchema, instances);
+            const itemsPath = [...path, item.name];
+            const { min, max } = collection;
+            const { length } = instances;
+            instances.forEach((itemInstance, index) => {
+                renderUIItems(item.items, collection.model, itemInstance, [...labels, `${ordinal(index)} ${composeString(item.label, references)}`], [...itemsPath, index], {
+                    ...collections,
+                    [item.name]: renderCollection(itemsPath, index, min, max, length, builder, references)
+                });
             });
         });
     }
-    function emitPage(page, model, collectionPath, labelContext, currentInstance) {
-        const options = page.inputs.flatMap((input) => {
-            const { path } = input;
-            const found = resolvePath(model, currentInstance, path, references);
-            if (found == null) {
-                return [];
-            }
-            const fullPath = [...collectionPath, ...path];
-            check.assert(BuilderPrimitiveSchema, found.value);
-            return [
-                {
-                    name: found.name,
-                    option: found.payload,
-                    value: found.value,
-                    update: (updateInstance, updateValue) => createInstance(builder, setPath(updateInstance, fullPath, updateValue), references),
-                    displayName: input.displayName && composeString(input.displayName, 'displayName'),
-                    kind: input.kind && composeString(input.kind, 'kind'),
-                    metadata: input.metadata && composeMetadata(input.metadata)
-                }
-            ];
-        });
-        if (options.length === 0) {
-            return;
-        }
-        layout.push({ label: composeLabel(page.label, labelContext), options });
-    }
-    function emitDescribe(describe, model, labelContext, currentInstance) {
-        const composedLabel = composeLabel(describe.label, labelContext);
-        const values = describe.inputs.flatMap((input) => {
-            const { path } = input;
-            const found = resolvePath(model, currentInstance, path, references);
-            if (found?.value == null) {
-                return [];
-            }
-            check.assert(BuilderPrimitiveSchema, found.value);
-            return [found.value];
-        });
-        if (values.length === 0) {
-            return;
-        }
-        description.push([composedLabel, values.join(' ')]);
-    }
-    function composeLabel(label, labelContext = []) {
-        const resolved = resolveReference(label, references);
-        check.assert(v.string(), resolved, 'Label did not resolve to a string! ❌');
-        if (labelContext.length === 0) {
-            return resolved;
-        }
-        if (resolved === '') {
-            return labelContext.join(', ');
-        }
-        return `${labelContext.join(', ')}, ${resolved}`;
-    }
-    function composeString(value, fieldLabel) {
-        const resolved = resolveReference(value, references);
-        check.assert(v.string(), resolved, `Input ${fieldLabel} did not resolve to a string! ❌`);
-        return resolved;
-    }
-    function composeMetadata(value) {
-        const resolved = resolveReference(value, references);
-        check.assert(BuilderRenderMetadataSchema, resolved, 'Input metadata did not resolve to an object! ❌');
-        return Object.fromEntries(Object.entries(resolved).map(([key, entry]) => [key, resolveReference(entry, references)]));
-    }
-    function findCollection(model, instance, collectionName) {
-        const entry = model.collections.find((candidate) => candidate.name === collectionName);
-        return entry == null ? null : resolveCollection(entry, model, instance, references);
-    }
-}
-function setPath(container, path, value) {
-    const [head, ...tail] = path;
-    if (typeof head === 'number') {
-        const arrayContainer = container ? [...container] : [];
-        arrayContainer[head] = tail.length === 0 ? value : setPath(arrayContainer[head], tail, value);
-        return arrayContainer;
-    }
-    const objectContainer = container ? container : {};
-    return {
-        ...objectContainer,
-        [head]: tail.length === 0 ? value : setPath(objectContainer[head], tail, value)
-    };
 }

package/dist/mappers/resolve.d.ts

@@ -1,12 +1,13 @@
 import type { BuilderCollectionConfigsSerialised, BuilderCollectionConfigValidated, BuilderCollectionSerialised, BuilderCollectionValidated, BuilderComponentConfigsSerialised, BuilderComponentConfigValidated, BuilderComponentSerialised, BuilderComponentValidated, BuilderModelValidated, BuilderOptionConfigsSerialised, BuilderOptionConfigValidated, BuilderOptionSerialised, BuilderOptionValidated, BuilderPath, BuilderReferences } from '../entities/index';
 import type { BuilderInstance } from '../instance';
+import * as v from 'valibot';
 export declare function resolveOption(option: BuilderOptionValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderOptionConfigValidated | null;
 export declare function resolveOptions(option: BuilderOptionSerialised, references?: BuilderReferences): BuilderOptionConfigsSerialised;
 export declare function resolveComponent(component: BuilderComponentValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderComponentConfigValidated | null;
 export declare function resolveComponents(component: BuilderComponentSerialised, references?: BuilderReferences): BuilderComponentConfigsSerialised;
 export declare function resolveCollection(collection: BuilderCollectionValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderCollectionConfigValidated | null;
 export declare function resolveCollections(collection: BuilderCollectionSerialised, references?: BuilderReferences): BuilderCollectionConfigsSerialised;
-export declare function resolveReference(value: unknown, references: BuilderReferences): unknown;
+export declare function resolveReference<Schema extends v.GenericSchema = v.GenericSchema<unknown>>(value: unknown, references: BuilderReferences, schema?: Schema): v.InferOutput<Schema>;
 export type ResolvedPath = {
     readonly name: string;
     readonly payload: BuilderOptionConfigValidated;

package/dist/mappers/resolve.js

@@ -1,38 +1,40 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, modelsMerge, whenBranches } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathsSchema, modelsMerge, whenBranches } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
-import { BuilderPrimitiveSchema } from '../primitive.js';
-import { BuilderRefSerialisedSchema } from '../references.js';
+import { BuilderPrimitiveSchema, NameSchema, NumberSchema } from '../primitive.js';
+import { BuilderRefSerialisedSchema, paramable } from '../references.js';
 export function resolveOption(option, model, instance, references = []) {
-    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, model, instance, references);
 }
 export function resolveOptions(option, references = []) {
-    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(option, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, references);
 }
 export function resolveComponent(component, model, instance, references = []) {
-    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, model, instance, references);
 }
 export function resolveComponents(component, references = []) {
-    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(component, BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema, references);
 }
 export function resolveCollection(collection, model, instance, references = []) {
-    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, model, instance, references);
+    return resolveEntryInstance(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, model, instance, references);
 }
 export function resolveCollections(collection, references = []) {
-    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, references);
+    return resolveEntryExhaustive(collection, BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema, references);
 }
-export function resolveReference(value, references) {
-    if (!check.is(BuilderRefSerialisedSchema, value)) {
-        return value;
+export function resolveReference(value, references, schema = v.unknown()) {
+    let resolved = value;
+    if (check.is(BuilderRefSerialisedSchema, value)) {
+        const found = references.find((entry) => entry.id === value.id);
+        check.invariant(found);
+        resolved = found.serialised;
     }
-    const found = references.find((entry) => entry.id === value.id);
-    check.truthy(found, `Reference '${value.id}' not found! ❌`);
-    return found.serialised;
+    check.assert(schema, resolved);
+    return resolved;
 }
 export function resolvePath(model, instance, path, references = []) {
     const optionName = path.at(-1);
-    check.assert(v.string(), optionName, 'Path must end at an option name! ❌');
+    check.assert(NameSchema, optionName);
     const descended = resolveItems(model, instance, path.slice(0, -1), references);
     if (descended == null) {
         return null;
@@ -40,7 +42,7 @@ export function resolvePath(model, instance, path, references = []) {
     const [scopeModel, scopeInstance] = descended;
     const merged = modelsMerge(scopeModel);
     const option = merged.options.find((entry) => entry.name === optionName);
-    check.truthy(option, `Path target '${optionName}' is not an option! ❌`);
+    check.invariant(option);
     const payload = resolveOption(option, scopeModel, scopeInstance, references);
     if (payload == null) {
         return null;
@@ -53,11 +55,11 @@ export function resolveItems(model, instance, pairs, references = []) {
         return [model, instance];
     }
     const [name, index, ...rest] = pairs;
-    check.assert(v.string(), name);
-    check.assert(v.number(), index, `Collection '${name}' must be followed by an index! ❌`);
+    check.assert(NameSchema, name);
+    check.assert(NumberSchema, index);
     const merged = modelsMerge(model);
     const collection = merged.collections.find((entry) => entry.name === name);
-    check.truthy(collection, `Path segment '${name}' is not a collection! ❌`);
+    check.invariant(collection);
     const resolved = resolveCollection(collection, model, instance, references);
     if (resolved == null) {
         return null;
@@ -70,12 +72,11 @@ export function resolveItems(model, instance, pairs, references = []) {
     }
     return resolveItems(resolved.model, item, rest, references);
 }
-function resolveEntryInstance(entry, schema, model, instance, references) {
-    const payload = resolveReference(entry.payload, references);
+function resolveEntryInstance(entry, schema, whenSchema, model, instance, references) {
+    const payload = resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema])));
     if (check.is(schema, payload)) {
         return payload;
     }
-    check.assert(BuilderWhenSerialisedSchema, payload);
     check.assert(BuilderPathsSchema, entry.paths);
     const config = payload;
     if (!entry.paths.every((path) => Boolean(resolvePath(model, instance, path, references)?.value))) {
@@ -103,6 +104,6 @@ function resolveEntryInstance(entry, schema, model, instance, references) {
         }
     }
 }
-function resolveEntryExhaustive(entry, schema, references) {
-    return whenBranches(resolveReference(entry.payload, references), schema);
+function resolveEntryExhaustive(entry, schema, whenSchema, references) {
+    return whenBranches(resolveReference(entry.payload, references, paramable(v.union([schema, whenSchema]))), schema);
 }

package/dist/mappers/variants/option-graph.js

@@ -2,7 +2,14 @@ import { BuilderPathSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } fr
 import { check } from '../../errors/index.js';
 import { resolveOption } from '../resolve.js';
 export function crossProduct(left, right) {
-    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+    return left.flatMap((leftModel) => right.flatMap((rightModel) => {
+        const rightKeys = new Set(Object.keys(rightModel));
+        const conflicted = Object.keys(leftModel).some((key) => rightKeys.has(key) && leftModel[key] !== rightModel[key]);
+        if (conflicted) {
+            return [];
+        }
+        return [{ ...leftModel, ...rightModel }];
+    }));
 }
 export function dependencyKeys(payload, paths = []) {
     const keys = new Set(paths.map(([first]) => String(first)));
@@ -25,7 +32,7 @@ export class BuilderOptionGraph {
     }
     get(name) {
         const graphPath = this.paths.find((graphPath) => graphPath.name === name);
-        check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
+        check.invariant(graphPath);
         return graphPath;
     }
     add(option, model) {
@@ -33,7 +40,7 @@ export class BuilderOptionGraph {
         const optionDependencyKeys = dependencyKeys(payload, paths);
         if (optionDependencyKeys.length === 0) {
             const payload = resolveOption(option, model, {});
-            check.truthy(payload, `Option '${option.name}' without dependencies must resolve! ❌`);
+            check.invariant(payload);
             const values = this.#optionValues(option.name, payload);
             return new BuilderOptionGraph([
                 ...this.paths,
@@ -65,7 +72,7 @@ export class BuilderOptionGraph {
     #mergePaths(dependencyKeys, graphPaths) {
         const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
             const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
-            check.truthy(dependencyPath, `Option dependency '${dependencyKey}' not found in graph! ❌`);
+            check.invariant(dependencyPath);
             return dependencyPath;
         });
         const [first, ...rest] = dependencyPaths;

package/dist/mappers/variants/variants.js

@@ -1,4 +1,4 @@
-import { BuilderModelSerialisedSchema, BuilderSerialisedSchema } from '../../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderSerialisedSchema, modelsMerge } from '../../entities/index.js';
 import { check } from '../../errors/index.js';
 import { resolveCollection } from '../resolve.js';
 import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
@@ -7,9 +7,10 @@ export function createVariants(entity) {
     return buildVariants(model);
 }
 function buildVariants(model) {
-    const options = optionGraph(model);
-    const nestedVariants = model.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
-        const resolved = resolveCollection(entry, model, instance);
+    const merged = modelsMerge(model);
+    const options = optionGraph(merged);
+    const nestedVariants = merged.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
+        const resolved = resolveCollection(entry, merged, instance);
         if (resolved == null) {
             return [];
         }
@@ -17,8 +18,8 @@ function buildVariants(model) {
         return [buildVariants(resolved.model)];
     }));
     return {
-        ...nestedVariants.reduce((merged, component) => ({ ...merged, ...component }), {}),
-        ...Object.fromEntries(model.components.map((component) => [
+        ...nestedVariants.reduce((accumulated, component) => ({ ...accumulated, ...component }), {}),
+        ...Object.fromEntries(merged.components.map((component) => [
             component.name,
             variantsFor(component, options).map((instance) => ({ instance }))
         ]))

package/dist/primitive.d.ts

@@ -1,4 +1,9 @@
 import * as v from 'valibot';
+export declare const StringSchema: v.StringSchema<undefined>;
+export declare const NumberSchema: v.NumberSchema<undefined>;
+export declare const BooleanSchema: v.BooleanSchema<undefined>;
+export declare const NameSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+export declare const IdSchema: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 export declare const BuilderPrimitiveSchema: v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
 export type BuilderPrimitive = v.InferOutput<typeof BuilderPrimitiveSchema>;
 export declare const BuilderPrimitivesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, v.ReadonlyAction<(string | number | boolean | null)[]>]>;

package/dist/primitive.js

@@ -1,3 +1,8 @@
 import * as v from 'valibot';
-export const BuilderPrimitiveSchema = v.nullable(v.union([v.string(), v.boolean(), v.number()]));
+export const StringSchema = v.string();
+export const NumberSchema = v.number();
+export const BooleanSchema = v.boolean();
+export const NameSchema = v.pipe(StringSchema, v.minLength(1));
+export const IdSchema = v.pipe(StringSchema, v.minLength(1));
+export const BuilderPrimitiveSchema = v.nullable(v.union([StringSchema, BooleanSchema, NumberSchema]));
 export const BuilderPrimitivesSchema = v.pipe(v.array(BuilderPrimitiveSchema), v.readonly());