@builder-builder/builder 0.0.25 → 0.0.26

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);
-            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),
-                    kind: input.kind && composeString(input.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);
-        if (labelContext.length === 0) {
-            return resolved;
-        }
-        if (resolved === '') {
-            return labelContext.join(', ');
-        }
-        return `${labelContext.join(', ')}, ${resolved}`;
-    }
-    function composeString(value) {
-        const resolved = resolveReference(value, references);
-        check.assert(v.string(), resolved);
-        return resolved;
-    }
-    function composeMetadata(value) {
-        const resolved = resolveReference(value, references);
-        check.assert(BuilderRenderMetadataSchema, resolved);
-        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.invariant(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);
+    check.assert(NameSchema, optionName);
     const descended = resolveItems(model, instance, path.slice(0, -1), references);
     if (descended == null) {
         return null;
@@ -53,8 +55,8 @@ 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);
+    check.assert(NameSchema, name);
+    check.assert(NumberSchema, index);
     const merged = modelsMerge(model);
     const collection = merged.collections.find((entry) => entry.name === name);
     check.invariant(collection);
@@ -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/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());

package/dist/public.d.ts

@@ -4,7 +4,7 @@ export type { BuilderEnvironment } from './environment';
 export type { BuilderError, BuilderErrorLocation, BuilderErrors } from './errors/index';
 export type { BuilderErrorKind } from './errors/index.js';
 export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariants } from './instance';
-export type { BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
+export type { BuilderOrder, BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderOptionUpdate, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './mappers/index';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
 export type { BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';

package/dist/references.d.ts

@@ -9,8 +9,8 @@ export declare class BuilderParameter<const Name extends string = string> {
 export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
 export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
@@ -25,7 +25,7 @@ export declare class BuilderRef {
 export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
 export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;
@@ -35,15 +35,15 @@ export declare function parameter<const Name extends string>(name: Name): Builde
 export declare function ref(id: string): BuilderRef;
 export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
-    readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "parameter";
     id: string;
     name: string;
 }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"ref", undefined>;
-    readonly id: v.StringSchema<undefined>;
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.ReadonlyAction<{
     type: "ref";
     id: string;

package/dist/references.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { check } from './errors/index.js';
+import { IdSchema, NameSchema } from './primitive.js';
 export class BuilderParameter {
     id;
     name;
@@ -9,7 +10,7 @@ export class BuilderParameter {
     }
 }
 export const BuilderParameterSchema = v.instance(BuilderParameter);
-export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: IdSchema, name: NameSchema }), v.readonly());
 export class BuilderRef {
     type = 'ref';
     id;
@@ -18,7 +19,7 @@ export class BuilderRef {
     }
 }
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string() }), v.readonly());
+export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: IdSchema }), v.readonly());
 export function parameter(name) {
     return new BuilderParameter(name);
 }

package/dist/validate/model.js

@@ -1,4 +1,5 @@
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
+import * as v from 'valibot';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
 import { BuilderErrorsScope, check } from '../errors/index.js';
 import { isParamable } from '../references.js';
 import { validate } from './brand.js';
@@ -41,8 +42,8 @@ export function validateModelStructure(input, resolve, errors) {
     };
     return walkStructure(input);
     function walkStructure(input) {
-        const resolved = resolve(input);
-        if (!check.is(BuilderModelSerialisedSchema, resolved)) {
+        const resolved = resolve(input, BuilderModelSerialisedSchema);
+        if (resolved == null) {
             return validate(serialise.model(model()));
         }
         const modelInput = resolved;
@@ -81,6 +82,15 @@ export function validateModelStructure(input, resolve, errors) {
             components,
             collections
         };
+        function payloadSchemaFor(kind) {
+            if (kind === 'option') {
+                return BuilderOptionConfigSerialisedSchema;
+            }
+            if (kind === 'component') {
+                return BuilderComponentConfigSerialisedSchema;
+            }
+            return BuilderCollectionConfigSerialisedSchema;
+        }
         function walkEntries(entries, kind, validateBranches) {
             const seenLocal = new Set();
             const items = [];
@@ -99,10 +109,11 @@ export function validateModelStructure(input, resolve, errors) {
         function resolveEntry(entry, seenLocal, kind) {
             let paths = entry.paths;
             if (entry.paths != null) {
-                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths));
+                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
                 paths = resolvedPaths ?? entry.paths;
             }
-            const payload = errors.scope('payload', () => resolve(entry.payload));
+            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderWhenSerialisedSchema]);
+            const payload = errors.scope('payload', () => resolve(entry.payload, payloadSchema));
             const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
             if (seenLocal.has(resolvedEntry.name)) {
                 if (kind === 'option') {

package/dist/validate/paths.js

@@ -1,9 +1,7 @@
-import * as v from 'valibot';
 import { BuilderModelSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
-const NumberSchema = v.number();
-const StringSchema = v.string();
+import { NameSchema, NumberSchema } from '../primitive.js';
 export function checkPath(model, path, errors) {
     if (path.length === 0) {
         errors.pathEmpty();
@@ -15,7 +13,7 @@ export function checkPath(model, path, errors) {
         return;
     }
     const optionName = path.at(-1);
-    if (!check.is(StringSchema, optionName)) {
+    if (!check.is(NameSchema, optionName)) {
         errors.scope(lastIndex, () => errors.pathInvalidSegment());
         return;
     }
@@ -39,7 +37,7 @@ function walkPath(models, remaining, offset, errors) {
         return models;
     }
     const [collectionName, index, ...rest] = remaining;
-    if (!check.is(StringSchema, collectionName)) {
+    if (!check.is(NameSchema, collectionName)) {
         errors.scope(offset, () => errors.pathInvalidSegment());
         return null;
     }

package/dist/validate/pricing.js

@@ -1,10 +1,9 @@
-import * as v from 'valibot';
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
 import { BuilderErrorsScope, check } from '../errors/index.js';
+import { NumberSchema } from '../primitive.js';
 import { validate } from './brand.js';
 import { resolver } from './resolve.js';
 const EMPTY_PRICING = validate(serialise.pricing(pricing()));
-const NumberSchema = v.number();
 export function validatePricing(input, references = [], errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
         errors.entityInvalid('pricing');
@@ -16,8 +15,8 @@ export function validatePricing(input, references = [], errors = new BuilderErro
 }
 export function validatePricingStructure(input, resolve, errors) {
     const rates = errors.scope('rates', () => input.rates.flatMap((entry, index) => {
-        const resolved = resolve(entry);
-        if (v.is(BuilderRatesSchema, resolved)) {
+        const resolved = resolve(entry, BuilderRatesSchema);
+        if (resolved != null) {
             return [resolved];
         }
         errors.scope(index, () => errors.pricingInvalidRateValue());
@@ -29,8 +28,8 @@ export function validatePricingStructure(input, resolve, errors) {
     }
     return { rates, formula };
     function resolveExpression(input) {
-        const resolved = resolve(input);
-        if (!check.is(BuilderPricingExpressionSchema, resolved)) {
+        const resolved = resolve(input, BuilderPricingExpressionSchema);
+        if (resolved == null) {
             errors.pricingMalformedExpression();
             return null;
         }

package/dist/validate/resolve.d.ts

@@ -1,4 +1,5 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
 import type { BuilderErrorsScope } from '../errors/index';
-export type BuilderResolve = (value: unknown) => unknown;
+import * as v from 'valibot';
+export type BuilderResolve = <S extends v.GenericSchema = v.GenericSchema<unknown>>(value: unknown, schema?: S) => v.InferOutput<S> | null;
 export declare function resolver(errors: BuilderErrorsScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;