@builder-builder/builder 0.0.20 → 0.0.22

package/README.md

@@ -1,38 +1,47 @@
-# sv
+# Builder Builder
 
-Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+## Setup
 
-## Creating a project
+```bash
+npm install
+supabase start
+npm run dev
+```
 
-If you're seeing this, you've probably already done this step. Congrats!
+## Deployment environments
 
-```bash
-# create a new project in the current directory
-npx sv create
+Where BB runs and which backing services it talks to.
 
-# create a new project in my-app
-npx sv create my-app
-```
+| Deployment        | Clerk instance   | Supabase instance       |
+| ----------------- | ---------------- | ----------------------- |
+| local dev         | Clerk test       | local supabase (docker) |
+| Vercel production | Clerk production | Supabase cloud project  |
 
-## Developing
+## Builder environments
 
-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+Every entity carries an `environment` of `development`, `staging`, or `production`. Same database, different rows. `development` rows are mutable; `staging` and `production` are immutable snapshots written when promoting from `development`.
 
-```bash
-npm run dev
+## API key scoping
 
-# or start the server and open the app in a new browser tab
-npm run dev -- --open
-```
+Each API key is minted in `/settings` with three properties:
 
-## Building
+| Property            | What it controls                                                                                                                                                                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Environment**     | Which dataset the key reads from: `development`, `staging`, or `production`.                                                                                                                                                                                                                                      |
+| **Profile**         | What the key can do. `read` keys can fetch; `readWrite` keys can also write variants.                                                                                                                                                                                                                             |
+| **Allowed origins** | Origin patterns (e.g. `https://*.example.com`) the key may be used from. Set this for browser keys; leave empty for server-to-server keys. The two modes are exclusive — a key with allowed origins requires an Origin header that matches, and a key without them rejects any request that has an Origin header. |
 
-To create a production version of your app:
+Keys are scoped to the org they were minted in and never see other orgs' data.
 
-```bash
-npm run build
-```
+| Environment   | `GET /api/builder/[id]` returns | `GET /api/builder/[id]/variants` returns |
+| ------------- | ------------------------------- | ---------------------------------------- |
+| `development` | live editable entity            | live editable variants                   |
+| `staging`     | staging snapshot                | staging snapshot variants                |
+| `production`  | production snapshot             | production snapshot variants             |
 
-You can preview the production build with `npm run preview`.
+## Scripts
 
-> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+- `npm run verify` — tests, check, format, lint.
+- `npm run test:integration:local` — integration tests against local Supabase.
+- `npm run db:types:local` — regenerate `database.types.ts` from local schema.
+- `npm run db:reset` — wipe local Supabase, re-diff migrations, regenerate types.

package/dist/bb.d.ts

@@ -1,25 +1,24 @@
-import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderPricingValidated, BuilderReferences, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderEntityKind, BuilderInstanceValidated, BuilderModelValidated, BuilderReferences, BuilderValidated, BuilderValidatedMap, BuilderVariantsValidated } from './entities/index';
 import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
-import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
+import type { BuilderInstance, BuilderInstanceInput, BuilderVariants } from './instance';
 import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
 import type { BuilderVariantsValidationOptions } from './validate/index';
 export type BBOptions = {
     readonly references?: BuilderReferences;
 };
+export type BuilderEntityValidators<Env extends BuilderEnvironment> = {
+    readonly [Kind in BuilderEntityKind]: (input: unknown) => BuilderEnvironmentResult<BuilderValidatedMap[Kind], Env>;
+};
 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>;
+    readonly validate: BuilderEntityValidators<Env> & {
         instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
-        variants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderEnvironmentResult<BuilderComponentVariantsValidated, Env>;
+        variants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions): BuilderEnvironmentResult<BuilderVariantsValidated, Env>;
     };
     instance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput): BuilderInstance;
     render(builder: BuilderValidated, instance: BuilderInstanceValidated): BuilderRenderResult;
-    order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated): BuilderOrder;
-    price(pricing: BuilderPricingValidated, order: BuilderOrder): number | null;
-    variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+    order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderVariantsValidated): BuilderOrder;
+    price(pricing: BuilderValidatedMap['pricing'], order: BuilderOrder): number | null;
+    variants(entity: BuilderValidated | BuilderModelValidated): BuilderVariants;
 };
 export declare const bb: typeof bbProduction & {
     development: typeof bbDevelopment;

package/dist/bb.js

@@ -1,4 +1,5 @@
-import { BuilderException } from './exception.js';
+import { validateBoolean, validateCollectionConfig, validateCollectionSelectMap, validateCollectionWhen, validateComponentConfig, validateComponentSelectMap, validateComponentWhen, validateExpectations, validateNumber, validateOptionSelectMap, validateOptionWhen, validatePath, validatePaths, validatePricingRates, validateSelect, validateString, validateToggle, validateUIDescribe, validateUIInput, validateUIItems, validateUIPage, validateUIPages } from './entities/index.js';
+import { BuilderException } from './errors/index.js';
 import { createInstance, createVariants, order, price, render } from './mappers/index.js';
 import { assertValidated, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from './validate/index.js';
 export const bb = Object.assign(bbProduction, {
@@ -17,8 +18,30 @@ function bbFactory(environment, references = []) {
         validate: {
             builder: (input) => throwInProd(validateBuilder(input, references)),
             model: (input) => throwInProd(validateModel(input, references)),
-            pricing: (input) => throwInProd(validatePricing(input, references)),
+            select: (input) => throwInProd(validateSelect(input, references)),
+            toggle: (input) => throwInProd(validateToggle(input, references)),
+            optionSelectMap: (input) => throwInProd(validateOptionSelectMap(input, references)),
+            optionWhen: (input) => throwInProd(validateOptionWhen(input, references)),
+            componentConfig: (input) => throwInProd(validateComponentConfig(input, references)),
+            componentSelectMap: (input) => throwInProd(validateComponentSelectMap(input, references)),
+            componentWhen: (input) => throwInProd(validateComponentWhen(input, references)),
+            collectionConfig: (input) => throwInProd(validateCollectionConfig(input, references)),
+            collectionSelectMap: (input) => throwInProd(validateCollectionSelectMap(input, references)),
+            collectionWhen: (input) => throwInProd(validateCollectionWhen(input, references)),
             ui: (input) => throwInProd(validateUI(input, references)),
+            uiDescribe: (input) => throwInProd(validateUIDescribe(input, references)),
+            uiItems: (input) => throwInProd(validateUIItems(input, references)),
+            uiPage: (input) => throwInProd(validateUIPage(input, references)),
+            uiPages: (input) => throwInProd(validateUIPages(input, references)),
+            uiInput: (input) => throwInProd(validateUIInput(input, references)),
+            pricing: (input) => throwInProd(validatePricing(input, references)),
+            pricingRates: (input) => throwInProd(validatePricingRates(input, references)),
+            expectations: (input) => throwInProd(validateExpectations(input, references)),
+            paths: (input) => throwInProd(validatePaths(input, references)),
+            path: (input) => throwInProd(validatePath(input, references)),
+            number: (input) => throwInProd(validateNumber(input, references)),
+            string: (input) => throwInProd(validateString(input, references)),
+            boolean: (input) => throwInProd(validateBoolean(input, references)),
             instance: (model, instance) => throwInProd(validateInstance(model, instance)),
             variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
         },

package/dist/client/client.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderBuilderClientOptions, BuilderBuilderGetResponse } from './schema.js';
+export type BuilderBuilderClient = {
+    builder: {
+        get(id: string): Promise<BuilderBuilderGetResponse>;
+    };
+};
+export declare function client(options: BuilderBuilderClientOptions): BuilderBuilderClient;

package/dist/client/client.js

@@ -0,0 +1,19 @@
+import * as v from 'valibot';
+import { BuilderException } from '../errors/index.js';
+import { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
+export function client(options) {
+    const { url, apiKey } = v.parse(BuilderBuilderClientOptionsSchema, options);
+    return {
+        builder: {
+            get: async (id) => {
+                const response = await fetch(`${url}/api/builder/${id}`, {
+                    headers: { 'X-Builder-Builder-Key': apiKey }
+                });
+                if (!response.ok) {
+                    throw new BuilderException([]);
+                }
+                return v.parse(BuilderBuilderGetResponseSchema, await response.json());
+            }
+        }
+    };
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderBuilderClientOptions, BuilderBuilderGetResponse } from './schema.js';
+export type { BuilderBuilderClient } from './client.js';
+export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
+export { client } from './client.js';

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
+export { client } from './client.js';

package/dist/client/schema.d.ts

@@ -0,0 +1,396 @@
+import * as v from 'valibot';
+export declare const BuilderBuilderClientOptionsSchema: v.ObjectSchema<{
+    readonly url: v.StringSchema<undefined>;
+    readonly apiKey: v.StringSchema<undefined>;
+}, undefined>;
+export type BuilderBuilderClientOptions = v.InferOutput<typeof BuilderBuilderClientOptionsSchema>;
+export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly serialised: v.GenericSchema<import("../index.js").BuilderSerialised>;
+    readonly references: v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly serialised: v.GenericSchema<string | number | boolean | readonly (string | number)[] | readonly (readonly (string | number)[])[] | import("../index.js").BuilderSerialised | import("../index.js").BuilderModelSerialised | Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+            tags?: readonly string[] | undefined;
+        }> | Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+            type: "parameter";
+            id: string;
+            name: string;
+        }> | Readonly<Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+            tags?: readonly string[] | undefined;
+        }>> | Readonly<Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }>>> | import("../index.js").BuilderWhenSerialised<Readonly<Readonly<{
+            type: "select";
+            readonly options: readonly [string, ...string[]];
+            defaultValue: string | null;
+            isOptional: boolean;
+            optionLabels: {
+                [x: string]: string;
+            };
+            tags?: readonly string[] | undefined;
+        }>> | Readonly<Readonly<{
+            type: "toggle";
+            valueType: "string" | "number" | "boolean";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }>>> | Readonly<{
+            fields: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | readonly Readonly<{
+                type: "component-field";
+                name: string;
+                valueType: "string" | "number" | "boolean";
+                isOptional: boolean;
+                tags?: readonly string[] | undefined;
+            }>[];
+            tags?: readonly string[] | undefined;
+        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+            type: "parameter";
+            id: string;
+            name: string;
+        }> | Readonly<{
+            fields: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | readonly Readonly<{
+                type: "component-field";
+                name: string;
+                valueType: "string" | "number" | "boolean";
+                isOptional: boolean;
+                tags?: readonly string[] | undefined;
+            }>[];
+            tags?: readonly string[] | undefined;
+        }>> | import("../index.js").BuilderWhenSerialised<Readonly<{
+            fields: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | readonly Readonly<{
+                type: "component-field";
+                name: string;
+                valueType: "string" | "number" | "boolean";
+                isOptional: boolean;
+                tags?: readonly string[] | undefined;
+            }>[];
+            tags?: readonly string[] | undefined;
+        }>> | Readonly<{
+            model: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | import("../index.js").BuilderModelSerialised;
+            min: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            max: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            tags?: readonly string[] | undefined;
+        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+            type: "parameter";
+            id: string;
+            name: string;
+        }> | Readonly<{
+            model: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | import("../index.js").BuilderModelSerialised;
+            min: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            max: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            tags?: readonly string[] | undefined;
+        }>> | import("../index.js").BuilderWhenSerialised<Readonly<{
+            model: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | import("../index.js").BuilderModelSerialised;
+            min: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            max: number | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            tags?: readonly string[] | undefined;
+        }>> | import("../index.js").BuilderUISerialised | Readonly<{
+            type: "input";
+            path: readonly (string | number)[] | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            displayName?: string | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | undefined;
+            kind?: string | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | undefined;
+            metadata?: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | Readonly<{
+                [x: string]: unknown;
+            }> | undefined;
+            tags?: readonly string[] | undefined;
+        }> | Readonly<{
+            type: "page";
+            label: string | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            inputs: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | readonly (Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | Readonly<{
+                type: "input";
+                path: readonly (string | number)[] | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }>;
+                displayName?: string | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | undefined;
+                kind?: string | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | undefined;
+                metadata?: Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | Readonly<{
+                    [x: string]: unknown;
+                }> | undefined;
+                tags?: readonly string[] | undefined;
+            }>)[];
+            tags?: readonly string[] | undefined;
+        }> | Readonly<{
+            type: "describe";
+            label: string | Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }>;
+            inputs: Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | readonly (Readonly<{
+                type: "parameter";
+                id: string;
+                name: string;
+            }> | Readonly<{
+                type: "ref";
+                id: string;
+            }> | Readonly<{
+                type: "input";
+                path: readonly (string | number)[] | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }>;
+                displayName?: string | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | undefined;
+                kind?: string | Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | undefined;
+                metadata?: Readonly<{
+                    type: "parameter";
+                    id: string;
+                    name: string;
+                }> | Readonly<{
+                    type: "ref";
+                    id: string;
+                }> | Readonly<{
+                    [x: string]: unknown;
+                }> | undefined;
+                tags?: readonly string[] | undefined;
+            }>)[];
+            tags?: readonly string[] | undefined;
+        }> | import("../index.js").BuilderUIPagesSerialised | readonly (Readonly<{
+            type: "parameter";
+            id: string;
+            name: string;
+        }> | Readonly<{
+            type: "ref";
+            id: string;
+        }> | import("../entities/index.js").BuilderUIItemSerialised)[] | import("../index.js").BuilderPricingSerialised | import("../entities/index.js").BuilderRates | readonly Readonly<{
+            name: string;
+            kind: "option" | "component" | "collection";
+        }>[]>;
+    }, undefined>, undefined>;
+    readonly variants: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly instance: v.GenericSchema<import("../instance.js").BuilderInstance>;
+        readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
+        readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        instance: import("../instance.js").BuilderInstance;
+        details?: {
+            [x: string]: string | number | boolean | null;
+        } | undefined;
+        tags?: readonly string[] | undefined;
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        instance: import("../instance.js").BuilderInstance;
+        details?: {
+            [x: string]: string | number | boolean | null;
+        } | undefined;
+        tags?: readonly string[] | undefined;
+    }>[]>]>, undefined>, v.ReadonlyAction<{
+        readonly [x: string]: readonly Readonly<{
+            instance: import("../instance.js").BuilderInstance;
+            details?: {
+                [x: string]: string | number | boolean | null;
+            } | undefined;
+            tags?: readonly string[] | undefined;
+        }>[];
+    }>]>;
+}, undefined>;
+export type BuilderBuilderGetResponse = v.InferOutput<typeof BuilderBuilderGetResponseSchema>;

package/dist/client/schema.js

@@ -0,0 +1,13 @@
+import * as v from 'valibot';
+import { BuilderReferencesSchema, BuilderSerialisedSchema } from '../entities/index.js';
+import { BuilderVariantsSchema } from '../instance.js';
+export const BuilderBuilderClientOptionsSchema = v.object({
+    url: v.string(),
+    apiKey: v.string()
+});
+export const BuilderBuilderGetResponseSchema = v.object({
+    name: v.string(),
+    serialised: BuilderSerialisedSchema,
+    references: BuilderReferencesSchema,
+    variants: BuilderVariantsSchema
+});

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

@@ -1,4 +1,4 @@
-import type { BuilderEntitySerialised } from '../kind';
 import type { BuilderRefSerialised } from '../../references';
+import type { BuilderEntitySerialised } from '../kind';
 export type BuilderBindings = Readonly<Record<string, unknown>>;
 export type BuilderBindingsSerialised = Readonly<Record<string, BuilderEntitySerialised | BuilderRefSerialised>>;

package/dist/entities/builder/builder.js

@@ -1,8 +1,8 @@
 import * as v from 'valibot';
 import { BuilderRefSerialisedSchema } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
 import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
 import { BuilderPricing, BuilderPricingSerialisedSchema } from '../pricing/index.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
 export class Builder {