@builder-builder/builder 0.0.13 → 0.0.15

package/dist/bb.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderPricingValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
 import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
 import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
 import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
@@ -9,6 +9,7 @@ export type BB<Env extends BuilderEnvironment = 'production'> = {
     readonly validate: {
         builder(input: unknown): BuilderEnvironmentResult<BuilderValidated, Env>;
         model(input: unknown): BuilderEnvironmentResult<BuilderModelValidated, Env>;
+        pricing(input: unknown): BuilderEnvironmentResult<BuilderPricingValidated, Env>;
         ui(input: unknown): BuilderEnvironmentResult<BuilderUIValidated, Env>;
         instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
         variants(model: BuilderModelValidated, input: unknown, options?: {
@@ -18,6 +19,7 @@ export type BB<Env extends BuilderEnvironment = 'production'> = {
     instance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput): BuilderInstance;
     render(builder: BuilderValidated, instance: BuilderInstanceValidated): BuilderRenderResult;
     order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated): BuilderOrder;
+    pricing(builder: BuilderValidated, order: BuilderOrder): number;
     variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
 };
 export declare const bb: typeof bbProd & {

package/dist/bb.js

@@ -1,5 +1,5 @@
 import { BuilderException } from './exception.js';
-import { assertValidated, createInstance, createVariants, order, render, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from './mappers/index.js';
+import { assertValidated, createInstance, createVariants, order, pricing, render, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from './mappers/index.js';
 export const bb = Object.assign(bbProd, {
     dev: bbDev
 });
@@ -14,6 +14,7 @@ function bbFactory(environment, references = []) {
         validate: {
             builder: (input) => throwInProd(validateBuilder(input, references)),
             model: (input) => throwInProd(validateModel(input, references)),
+            pricing: (input) => throwInProd(validatePricing(input)),
             ui: (input) => throwInProd(validateUI(input, references)),
             instance: (model, instance) => throwInProd(validateInstance(model, instance)),
             variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
@@ -33,6 +34,10 @@ function bbFactory(environment, references = []) {
             assertValidated(variants);
             return order(model, instance, variants, references);
         },
+        pricing: (builder, orderResult) => {
+            assertValidated(builder);
+            return pricing(builder.model, builder.pricing, orderResult, references);
+        },
         variants: (entity) => {
             assertValidated(entity);
             return createVariants(entity);

package/dist/check.d.ts

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

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { writeFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+import { generateOrderType } from './codegen/index.js';
+const DEFAULT_API_URL = 'https://builder-builder.com';
+run().catch((caught) => {
+    const message = caught instanceof Error ? caught.message : String(caught);
+    process.stderr.write(`bb: ${message}\n`);
+    process.exit(1);
+});
+async function run() {
+    const { values } = parseArgs({
+        options: {
+            id: { type: 'string' },
+            out: { type: 'string' },
+            api: { type: 'string', default: DEFAULT_API_URL },
+            key: { type: 'string' }
+        },
+        strict: true
+    });
+    const id = values.id;
+    const out = values.out;
+    if (id == null || out == null) {
+        process.stderr.write('Usage: bb --id <entity-id> --out <file> [--api <url>] [--key <api-key>]\n');
+        process.exit(1);
+        return;
+    }
+    const apiUrl = values.api ?? DEFAULT_API_URL;
+    const apiKey = values.key ?? process.env.BB_API_KEY;
+    if (apiKey == null || apiKey.length === 0) {
+        throw new Error('missing API key — pass --key or set BB_API_KEY');
+    }
+    const entity = await fetchEntity({ apiUrl, id, apiKey });
+    const generated = generateOrderType({ name: entity.name, builder: entity.builder });
+    const fetchedAt = new Date().toISOString();
+    const header = `// AUTO-GENERATED — DO NOT EDIT\n` +
+        `// Source: ${id} (${entity.name}) — fetched ${fetchedAt}\n` +
+        `// Regenerate: bb --id ${id} --out ${out}\n\n`;
+    writeFileSync(out, header + generated);
+    process.stdout.write(`bb: wrote ${out}\n`);
+}
+async function fetchEntity(options) {
+    const url = `${options.apiUrl.replace(/\/$/, '')}/api/builder/${options.id}`;
+    const response = await fetch(url, {
+        headers: { 'X-Builder-Builder-Key': options.apiKey }
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`fetch ${url} failed: ${response.status} ${response.statusText} — ${body}`);
+    }
+    const payload = (await response.json());
+    return payload;
+}

package/dist/codegen/index.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderRefEntities, BuilderSerialised } from '../entities/index.js';
+export type GenerateOrderTypeInput = {
+    readonly name: string;
+    readonly builder: BuilderSerialised;
+    readonly references?: BuilderRefEntities;
+};
+export declare function generateOrderType(input: GenerateOrderTypeInput): string;

package/dist/codegen/index.js

@@ -0,0 +1,212 @@
+import ts from 'typescript';
+import * as v from 'valibot';
+import { check } from '../check.js';
+import { BuilderException } from '../exception.js';
+import { optionGraph, variantsFor } from '../mappers/index.js';
+import { validateBuilder } from '../validate/index.js';
+import { tsmember, tstype } from './template.js';
+export function generateOrderType(input) {
+    const [validated, errors] = validateBuilder(input.builder, input.references ?? []);
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+    const typeName = `${pascalCase(input.name)}Order`;
+    const typeNode = renderModelOrder(validated.model);
+    const declaration = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], typeName, undefined, typeNode);
+    const sourceFile = ts.createSourceFile('generated.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    return `${printer.printNode(ts.EmitHint.Unspecified, declaration, sourceFile)}\n`;
+}
+function renderModelOrder(model) {
+    const graph = optionGraph(model);
+    const componentMembers = model.components.map((component) => {
+        return renderComponentMember(component, model, graph);
+    });
+    const collectionMembers = model.collections.map((collection) => {
+        return renderCollectionMember(collection);
+    });
+    return ts.factory.createTypeLiteralNode([...componentMembers, ...collectionMembers]);
+}
+function renderComponentMember(component, model, graph) {
+    const variant = renderComponentVariant(component, model, graph);
+    return tsmember('readonly <%= name %>: <%= variant %> | null;', {
+        name: propertyName(component.name),
+        variant
+    });
+}
+function renderComponentVariant(component, model, graph) {
+    const instance = renderComponentInstance(component, model, graph);
+    const detailFields = extractDetailFields(component.payload);
+    if (detailFields.length === 0) {
+        return tstype('{ readonly instance: <%= i %> }', { i: instance });
+    }
+    const details = renderDetailFields(detailFields);
+    return tstype('{ readonly instance: <%= i %>; readonly details: <%= d %> }', {
+        i: instance,
+        d: details
+    });
+}
+function renderComponentInstance(component, model, graph) {
+    rejectUnsupportedDependencyPaths(component);
+    const observedValues = perKeyValueSets(variantsFor(component, graph));
+    const members = [];
+    observedValues.forEach((values, key) => {
+        members.push(tsmember('readonly <%= name %>: <%= type %>;', {
+            name: propertyName(key),
+            type: renderOptionValueType(key, values, model)
+        }));
+    });
+    return ts.factory.createTypeLiteralNode(members);
+}
+function rejectUnsupportedDependencyPaths(component) {
+    const paths = component.paths ?? [];
+    paths.forEach((path) => {
+        if (path.length !== 1) {
+            throw new Error(`codegen: multi-segment dependency paths are not yet supported (component '${component.name}', path ${JSON.stringify(path)})`);
+        }
+        const [head] = path;
+        check.assert(v.string(), head, `codegen invariant: component dependency path head must be a string (component '${component.name}', path ${JSON.stringify(path)})! ❌`);
+    });
+}
+function perKeyValueSets(variants) {
+    const result = new Map();
+    variants.forEach((instance) => {
+        Object.entries(instance).forEach(([key, value]) => {
+            const existing = result.get(key) ?? new Set();
+            existing.add(value);
+            result.set(key, existing);
+        });
+    });
+    return result;
+}
+function renderOptionValueType(name, observedValues, model) {
+    const option = model.options.find((candidate) => candidate.name === name);
+    check.truthy(option, `codegen invariant: option '${name}' referenced by a component must be defined in the model! ❌`);
+    return renderOptionValueShape(option.payload, observedValues);
+}
+function renderOptionValueShape(payload, observedValues) {
+    if (payload.type === 'toggle') {
+        return maybeNullable(primitiveTypeNode(payload.valueType), payload.isOptional);
+    }
+    if (payload.type === 'select') {
+        const literals = Array.from(observedValues)
+            .filter((value) => typeof value === 'string')
+            .map((value) => {
+            return ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));
+        });
+        return maybeNullable(unionOf(literals), payload.isOptional);
+    }
+    if (payload.type === 'enable' || payload.type === 'unless') {
+        return renderOptionValueShape(payload.payload, observedValues);
+    }
+    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
+    const [first] = branches;
+    if (first == null) {
+        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
+    }
+    return renderOptionValueShape(first, observedValues);
+}
+function extractDetailFields(payload) {
+    if (!('type' in payload)) {
+        return payload.fields;
+    }
+    if (payload.type === 'enable' || payload.type === 'unless') {
+        return extractDetailFields(payload.payload);
+    }
+    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
+    const [first] = branches;
+    if (first == null) {
+        return [];
+    }
+    return extractDetailFields(first);
+}
+function renderDetailFields(fields) {
+    const members = fields.map((field) => {
+        return tsmember('readonly <%= name %>: <%= type %>;', {
+            name: propertyName(field.name),
+            type: maybeNullable(primitiveTypeNode(field.valueType), field.isOptional)
+        });
+    });
+    return ts.factory.createTypeLiteralNode(members);
+}
+function renderCollectionMember(collection) {
+    const config = extractCollectionConfig(collection.payload);
+    const itemNode = renderModelOrder(config.model);
+    const tupleSize = fixedTupleSize(config.min, config.max);
+    const value = tupleSize == null
+        ? tstype('ReadonlyArray<<%= i %>>', { i: itemNode })
+        : tstype('readonly [%= items %]', {
+            items: Array.from({ length: tupleSize }, () => itemNode)
+        });
+    return tsmember('readonly <%= name %>: <%= value %>;', {
+        name: propertyName(collection.name),
+        value
+    });
+}
+function extractCollectionConfig(payload) {
+    if (!('type' in payload)) {
+        return payload;
+    }
+    if (payload.type === 'enable' || payload.type === 'unless') {
+        return extractCollectionConfig(payload.payload);
+    }
+    const branches = Object.values(payload.selectMap).filter((branch) => branch != null);
+    const [first] = branches;
+    if (first == null) {
+        throw new Error(`codegen: collection 'match' has no non-null branch`);
+    }
+    return extractCollectionConfig(first);
+}
+function fixedTupleSize(min, max) {
+    if (min !== max) {
+        return null;
+    }
+    if (!Number.isInteger(min) || min < 0) {
+        return null;
+    }
+    return min;
+}
+function propertyName(name) {
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
+        return ts.factory.createIdentifier(name);
+    }
+    return ts.factory.createStringLiteral(name);
+}
+function primitiveTypeNode(valueType) {
+    if (valueType === 'string') {
+        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+    }
+    if (valueType === 'number') {
+        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+    }
+    return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+}
+function unionOf(members) {
+    const [first, ...rest] = members;
+    if (first == null) {
+        return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword);
+    }
+    if (rest.length === 0) {
+        return first;
+    }
+    return ts.factory.createUnionTypeNode([first, ...rest]);
+}
+function maybeNullable(node, isNullable) {
+    if (!isNullable) {
+        return node;
+    }
+    return ts.factory.createUnionTypeNode([
+        node,
+        ts.factory.createLiteralTypeNode(ts.factory.createNull())
+    ]);
+}
+function pascalCase(name) {
+    const words = name.split(/[\s\-_]+/).filter((word) => word.length > 0);
+    if (words.length === 0) {
+        throw new Error(`codegen: name '${name}' produces an empty type name`);
+    }
+    return words
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('')
+        .replace(/[^A-Za-z0-9]/g, '');
+}

package/dist/codegen/template.d.ts

@@ -0,0 +1,5 @@
+import type ts from 'typescript';
+type TemplateData = Readonly<Record<string, string | ts.Node | ReadonlyArray<ts.Node>>>;
+export declare function tstype(template: string, data?: TemplateData): ts.TypeNode;
+export declare function tsmember(template: string, data?: TemplateData): ts.TypeElement;
+export {};

package/dist/codegen/template.js

@@ -0,0 +1,17 @@
+import { tsquery } from '@phenomnomnominal/tsquery';
+import { tstemplate } from '@phenomnomnominal/tstemplate';
+import { check } from '../check.js';
+export function tstype(template, data = {}) {
+    const sourceFile = tstemplate(`type __ = ${template};`, data);
+    const [declaration] = tsquery(sourceFile, 'TypeAliasDeclaration');
+    check.truthy(declaration, `tstype invariant: template produced no TypeAliasDeclaration! ❌`);
+    return declaration.type;
+}
+export function tsmember(template, data = {}) {
+    const sourceFile = tstemplate(`type __ = { ${template} };`, data);
+    const [literal] = tsquery(sourceFile, 'TypeLiteral');
+    check.truthy(literal, `tsmember invariant: template produced no TypeLiteral! ❌`);
+    const [member] = literal.members;
+    check.truthy(member, `tsmember invariant: template produced an empty TypeLiteral! ❌`);
+    return member;
+}

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

@@ -1,21 +1,31 @@
 import type { BuilderModelBindings, BuilderModelBoundState } from '../model/bind';
 import type { BuilderModelState } from '../model/state';
+import type { BuilderPricing } from '../pricing';
+import type { BuilderTags } from '../tags';
+import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderBindings, BuilderBindingsSerialised } from './bind';
 import * as v from 'valibot';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export declare class Builder<State extends BuilderModelState = BuilderModelState> {
+    #private;
     readonly type: 'builder';
     readonly model: BuilderModel<State>;
     readonly ui: BuilderUI;
     readonly bindings: BuilderBindings;
-    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, bindings?: BuilderBindings);
+    readonly tags?: BuilderTags;
+    readonly pricing?: Paramable<BuilderPricing>;
+    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, bindings?: BuilderBindings, tags?: BuilderTags, pricing?: Paramable<BuilderPricing>);
     bind<const Bindings extends BuilderBindings>(extra: Bindings): Bindings extends BuilderModelBindings<State> ? Builder<BuilderModelBoundState<State, Bindings>> : Builder<State>;
+    tag(...tags: Array<string>): Builder<State>;
+    priced(pricing: Paramable<BuilderPricing>): Builder<State>;
 }
 export declare const BuilderSchema: v.InstanceSchema<typeof Builder, undefined>;
 export interface BuilderSerialised {
     readonly model: v.InferOutput<typeof BuilderModelSerialisedSchema>;
     readonly ui: v.InferOutput<typeof BuilderUISerialisedSchema>;
     readonly bindings: BuilderBindingsSerialised;
+    readonly tags?: BuilderTags;
+    readonly pricing?: ParamableSerialised<BuilderPricing>;
 }
 export declare const BuilderSerialisedSchema: v.GenericSchema<BuilderSerialised>;

package/dist/entities/builder/builder.js

@@ -1,27 +1,43 @@
 import * as v from 'valibot';
-import { BuilderRefSerialisedSchema } from '../../references.js';
+import { BuilderRefSerialisedSchema, paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderPricingSchema } from '../pricing.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export class Builder {
     model;
     ui;
     bindings;
-    constructor(model = new BuilderModel(), ui = new BuilderUI([], [], []), bindings = {}) {
+    tags;
+    pricing;
+    constructor(model = new BuilderModel(), ui = new BuilderUI([], [], []), bindings = {}, tags, pricing) {
         this.model = model;
         this.ui = ui;
         this.bindings = bindings;
+        this.tags = tags;
+        this.pricing = pricing;
+    }
+    #next(patch) {
+        return new Builder(this.model, this.ui, patch.bindings ?? this.bindings, patch.tags ?? this.tags, patch.pricing ?? this.pricing);
     }
     bind(extra) {
-        return new Builder(this.model, this.ui, {
-            ...this.bindings,
-            ...extra
+        return this.#next({
+            bindings: { ...this.bindings, ...extra }
         });
     }
+    tag(...tags) {
+        return this.#next({ tags });
+    }
+    priced(pricing) {
+        return this.#next({ pricing });
+    }
 }
 export const BuilderSchema = v.instance(Builder);
 export const BuilderSerialisedSchema = serialisable(v.object({
     model: BuilderModelSerialisedSchema,
     ui: BuilderUISerialisedSchema,
-    bindings: v.pipe(v.record(v.string(), v.union([BuilderRefSerialisedSchema, v.unknown()])), v.readonly())
+    bindings: v.pipe(v.record(v.string(), v.union([BuilderRefSerialisedSchema, v.unknown()])), v.readonly()),
+    tags: v.optional(BuilderTagsSchema),
+    pricing: v.optional(paramable(BuilderPricingSchema))
 }));

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

@@ -1,6 +1,7 @@
 import type { BuilderPaths } from '../../paths';
 import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderModelState } from '../model/index';
+import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
 import type { BuilderCollectionConfig, BuilderCollectionConfigSerialised } from './config';
 import type { BuilderCollectionWhen } from './when';
@@ -11,7 +12,9 @@ export declare class BuilderCollection<const Name extends string = string, const
     readonly name: Name;
     readonly payload: Payload;
     readonly paths?: Paths;
-    constructor(name: Name, payload: Payload, paths?: Paths);
+    readonly tags?: BuilderTags;
+    constructor(name: Name, payload: Payload, paths?: Paths, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderCollection<Name, Payload, Paths>;
 }
 export declare const BuilderCollectionSchema: v.InstanceSchema<typeof BuilderCollection, undefined>;
 export type BuilderCollections = ReadonlyArray<BuilderCollection>;
@@ -40,6 +43,7 @@ export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema<Buil
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>>>;
 export type BuilderCollectionWhenSerialised = BuilderWhenSerialised<BuilderCollectionConfigSerialised>;
 export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
@@ -71,11 +75,13 @@ export declare const BuilderCollectionSelectMapSerialisedSchema: v.GenericSchema
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>>>;
 export type BuilderCollectionSerialised = {
     readonly name: string;
     readonly paths?: ParamableSerialised<BuilderPaths>;
     readonly payload: ParamableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
+    readonly tags?: BuilderTags;
 };
 export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
 export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;

package/dist/entities/collection/collection.js

@@ -2,16 +2,22 @@ import * as v from 'valibot';
 import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderCollectionConfigSerialisedSchema } from './config.js';
 export class BuilderCollection {
     name;
     payload;
     paths;
-    constructor(name, payload, paths) {
+    tags;
+    constructor(name, payload, paths, tags) {
         this.name = name;
         this.payload = payload;
         this.paths = paths;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderCollection(this.name, this.payload, this.paths, tags);
     }
 }
 export const BuilderCollectionSchema = v.instance(BuilderCollection);
@@ -20,6 +26,7 @@ export const BuilderCollectionSelectMapSerialisedSchema = createSelectMapSeriali
 export const BuilderCollectionSerialisedSchema = serialisable(v.object({
     name: v.string(),
     payload: paramable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
-    paths: v.optional(paramable(BuilderPathsSchema))
+    paths: v.optional(paramable(BuilderPathsSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());

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

@@ -1,12 +1,15 @@
 import type { Paramable } from '../../references';
 import type { BuilderModelGeneric } from '../model/index';
+import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export declare class BuilderCollectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>> {
     readonly type: 'collection-config';
     readonly model: Model;
     readonly min: Min;
     readonly max: Max;
-    constructor(model: Model, min: Min, max: Max);
+    readonly tags?: BuilderTags;
+    constructor(model: Model, min: Min, max: Max, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderCollectionConfig<Model, Min, Max>;
 }
 export declare const BuilderCollectionConfigSchema: v.InstanceSchema<typeof BuilderCollectionConfig, undefined>;
 export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -55,6 +58,7 @@ export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<r
         type: "ref";
         id: string;
     }>]>, v.NumberSchema<undefined>], undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     model: Readonly<{
         type: "parameter";
@@ -80,6 +84,7 @@ export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<r
         type: "ref";
         id: string;
     }>;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderCollectionConfigSerialised = v.InferOutput<typeof BuilderCollectionConfigSerialisedSchema>;
 export declare function collectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>>(model: Model, min: Min, max: Max): BuilderCollectionConfig<Model, Min, Max>;

package/dist/entities/collection/config.js

@@ -2,21 +2,28 @@ import * as v from 'valibot';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderTagsSchema } from '../tags.js';
 export class BuilderCollectionConfig {
     model;
     min;
     max;
-    constructor(model, min, max) {
+    tags;
+    constructor(model, min, max, tags) {
         this.model = model;
         this.min = min;
         this.max = max;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderCollectionConfig(this.model, this.min, this.max, tags);
     }
 }
 export const BuilderCollectionConfigSchema = v.instance(BuilderCollectionConfig);
 export const BuilderCollectionConfigSerialisedSchema = serialisable(v.object({
     model: paramable(v.lazy(() => BuilderModelSerialisedSchema)),
     min: paramable(v.number()),
-    max: paramable(v.number())
+    max: paramable(v.number()),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function collectionConfig(model, min, max) {
     return new BuilderCollectionConfig(model, min, max);