@pascal-app/core 1.0.0 → 1.0.1

package/dist/procedural-items/fixtures.js

@@ -0,0 +1,349 @@
+import { parseRecipe } from './recipe.js';
+const add = (...args) => ({ op: 'add', args });
+const sub = (...args) => ({ op: 'sub', args });
+const mul = (...args) => ({ op: 'mul', args });
+const div = (...args) => ({ op: 'div', args });
+const p = (id, label, value, min, max, step, extra = {}) => ({
+    id,
+    label,
+    default: value,
+    min,
+    max,
+    step,
+    unit: 'm',
+    ...extra,
+});
+export const shelfRecipe = parseRecipe({
+    version: 1,
+    name: 'Everyday shelf',
+    description: 'An open timber bookcase with adjustable shelves and a contrasting back.',
+    parameters: [
+        p('width', 'Width', 1.2, 0.6, 2.4, 0.05, { axis: 'x' }),
+        p('height', 'Height', 1.8, 0.8, 2.5, 0.05, { axis: 'y' }),
+        p('depth', 'Depth', 0.4, 0.25, 0.7, 0.025, { axis: 'z' }),
+        p('rows', 'Shelves', 4, 2, 7, 1, { unit: 'count', part: 'shelves' }),
+        p('thickness', 'Board thickness', 0.03, 0.015, 0.06, 0.005, { part: 'frame' }),
+    ],
+    slots: [
+        { id: 'frame', label: 'Frame', color: '#b58a60' },
+        { id: 'shelves', label: 'Shelves', color: '#d5b38d' },
+        { id: 'back', label: 'Back', color: '#495b50' },
+    ],
+    parts: [
+        {
+            id: 'frame',
+            label: 'Frame',
+            count: 2,
+            shapes: [
+                {
+                    id: 'side',
+                    primitive: 'box',
+                    slot: 'frame',
+                    size: ['thickness', 'height', 'depth'],
+                    position: [mul(sub('index', 0.5), sub('width', 'thickness')), div('height', 2), 0],
+                },
+            ],
+        },
+        {
+            id: 'shelves',
+            label: 'Shelves',
+            count: 'rows',
+            shapes: [
+                {
+                    id: 'board',
+                    primitive: 'box',
+                    slot: 'shelves',
+                    size: [sub('width', mul(2, 'thickness')), 'thickness', 'depth'],
+                    position: [
+                        0,
+                        add(div('thickness', 2), mul('index', div(sub('height', 'thickness'), sub('rows', 1)))),
+                        0,
+                    ],
+                    support: true,
+                },
+            ],
+        },
+        {
+            id: 'back',
+            label: 'Back panel',
+            count: 1,
+            shapes: [
+                {
+                    id: 'panel',
+                    primitive: 'box',
+                    slot: 'back',
+                    size: [sub('width', mul(2, 'thickness')), 'height', 0.012],
+                    position: [0, div('height', 2), add(div('depth', -2), 0.006)],
+                },
+            ],
+        },
+    ],
+    constraints: [],
+});
+export const bedRecipe = parseRecipe({
+    version: 1,
+    name: 'Quiet bed',
+    description: 'An upholstered bed with a timber frame and independently adjustable pillows.',
+    parameters: [
+        p('width', 'Width', 1.6, 1, 2.2, 0.05, { axis: 'x' }),
+        p('length', 'Length', 2.1, 1.8, 2.5, 0.05, { axis: 'z' }),
+        p('headboard_height', 'Headboard height', 1.1, 0.75, 1.5, 0.05, {
+            axis: 'y',
+            part: 'headboard',
+        }),
+        p('frame_height', 'Frame height', 0.3, 0.2, 0.5, 0.025, { part: 'frame' }),
+        p('pillows', 'Pillow count', 2, 1, 3, 1, { unit: 'count', part: 'pillows' }),
+        p('pillow_depth', 'Pillow depth', 0.38, 0.25, 0.55, 0.025, { part: 'pillows' }),
+    ],
+    slots: [
+        { id: 'wood', label: 'Frame', color: '#875d42' },
+        { id: 'fabric', label: 'Headboard', color: '#a8a08f' },
+        { id: 'linen', label: 'Bedding', color: '#e8dfce' },
+        { id: 'pillows', label: 'Pillows', color: '#a3b5a8' },
+    ],
+    parts: [
+        {
+            id: 'frame',
+            label: 'Bed frame',
+            count: 1,
+            shapes: [
+                {
+                    id: 'base',
+                    primitive: 'roundedBox',
+                    slot: 'wood',
+                    size: ['width', 'frame_height', 'length'],
+                    position: [0, div('frame_height', 2), 0],
+                    radius: 0.035,
+                },
+            ],
+        },
+        {
+            id: 'mattress',
+            label: 'Mattress',
+            count: 1,
+            shapes: [
+                {
+                    id: 'mattress',
+                    primitive: 'roundedBox',
+                    slot: 'linen',
+                    size: [sub('width', 0.08), 0.22, sub('length', 0.12)],
+                    position: [0, add('frame_height', 0.11), 0.03],
+                    radius: 0.08,
+                    support: true,
+                },
+            ],
+        },
+        {
+            id: 'headboard',
+            label: 'Headboard',
+            count: 1,
+            shapes: [
+                {
+                    id: 'panel',
+                    primitive: 'roundedBox',
+                    slot: 'fabric',
+                    size: [add('width', 0.04), 'headboard_height', 0.09],
+                    position: [0, div('headboard_height', 2), div('length', -2)],
+                    radius: 0.035,
+                },
+            ],
+        },
+        {
+            id: 'pillows',
+            label: 'Pillows',
+            count: 'pillows',
+            shapes: [
+                {
+                    id: 'pillow',
+                    primitive: 'roundedBox',
+                    slot: 'pillows',
+                    size: [sub(div(sub('width', 0.16), 'pillows'), 0.04), 0.15, 'pillow_depth'],
+                    position: [
+                        mul(sub(add('index', 0.5), div('pillows', 2)), div(sub('width', 0.16), 'pillows')),
+                        add('frame_height', 0.295),
+                        add(div('length', -2), div('pillow_depth', 2), 0.16),
+                    ],
+                    radius: 0.065,
+                },
+            ],
+        },
+    ],
+    constraints: [],
+});
+export const radiatorRecipe = parseRecipe({
+    version: 1,
+    name: 'Wall radiator',
+    description: 'A wall-mounted panel radiator with adjustable width, height and fins. The valve stays outside the nominal width.',
+    classification: {
+        category: 'radiator',
+        functionTags: ['heating'],
+        tags: ['radiator', 'wall-mounted'],
+    },
+    mounting: { attachTo: 'wall-side', reference: 'back' },
+    parameters: [
+        p('width', 'Panel width', 1.2, 0.6, 2, 0.05, { axis: 'x' }),
+        p('height', 'Panel height', 0.6, 0.3, 0.9, 0.05, { axis: 'y' }),
+        p('depth', 'Panel depth', 0.1, 0.06, 0.18, 0.01, { axis: 'z' }),
+        p('fins', 'Fins', 12, 4, 24, 1, { unit: 'count', part: 'panel' }),
+    ],
+    slots: [
+        { id: 'body', label: 'Painted metal', color: '#eeeae2' },
+        { id: 'valve', label: 'Valve', color: '#a5adb5' },
+    ],
+    surfaces: [
+        {
+            id: 'back',
+            label: 'Wall mounting face',
+            position: [0, div('height', 2), div('depth', -2)],
+            rotation: [-Math.PI / 2, 0, 0],
+            size: ['width', 'height'],
+        },
+    ],
+    parts: [
+        {
+            id: 'panel',
+            label: 'Radiator fins',
+            count: 'fins',
+            shapes: [
+                {
+                    id: 'fin',
+                    primitive: 'roundedBox',
+                    slot: 'body',
+                    size: [sub(div('width', 'fins'), 0.008), 'height', 'depth'],
+                    position: [
+                        sub(mul(add('index', 0.5), div('width', 'fins')), div('width', 2)),
+                        div('height', 2),
+                        0,
+                    ],
+                    radius: 0.006,
+                },
+            ],
+        },
+        {
+            id: 'pipes',
+            label: 'Manifolds',
+            count: 2,
+            shapes: [
+                {
+                    id: 'pipe',
+                    primitive: 'cylinder',
+                    slot: 'body',
+                    size: [0.035, 'width', 0.035],
+                    position: [0, add(0.055, mul('index', sub('height', 0.11))), 0],
+                    rotation: [0, 0, Math.PI / 2],
+                },
+            ],
+        },
+        {
+            id: 'valve',
+            label: 'Valve',
+            count: 1,
+            shapes: [
+                {
+                    id: 'knob',
+                    primitive: 'cylinder',
+                    slot: 'valve',
+                    size: [0.06, 0.08, 0.06],
+                    position: [add(div('width', 2), 0.04), 0.08, 0],
+                    rotation: [0, 0, Math.PI / 2],
+                },
+            ],
+        },
+    ],
+    constraints: [],
+});
+export const counterRecipe = parseRecipe({
+    version: 1,
+    name: 'Kitchen counter',
+    description: 'A floor-supported counter with a splashback and a named worktop for real items. Nearby walls do not host it.',
+    classification: { category: 'counter', functionTags: ['kitchen'], tags: ['counter', 'worktop'] },
+    parameters: [
+        p('width', 'Width', 1.6, 0.6, 2.8, 0.05, { axis: 'x' }),
+        p('height', 'Worktop height', 0.9, 0.7, 1.1, 0.025, { axis: 'y' }),
+        p('depth', 'Depth', 0.65, 0.35, 0.9, 0.025, { axis: 'z' }),
+        p('splashback', 'Splashback height', 0.2, 0.05, 0.4, 0.025, { part: 'splashback' }),
+    ],
+    slots: [
+        { id: 'cabinet', label: 'Cabinet', color: '#668579' },
+        { id: 'stone', label: 'Worktop and splashback', color: '#ded8cb' },
+    ],
+    surfaces: [
+        {
+            id: 'worktop',
+            label: 'Worktop',
+            position: [0, 'height', 0.025],
+            size: [sub('width', 0.04), sub('depth', 0.09)],
+        },
+    ],
+    parts: [
+        {
+            id: 'cabinet',
+            label: 'Cabinet',
+            count: 1,
+            shapes: [
+                {
+                    id: 'body',
+                    primitive: 'box',
+                    slot: 'cabinet',
+                    size: [sub('width', 0.04), sub('height', 0.04), sub('depth', 0.04)],
+                    position: [0, div(sub('height', 0.04), 2), 0],
+                },
+            ],
+        },
+        {
+            id: 'worktop',
+            label: 'Worktop',
+            count: 1,
+            shapes: [
+                {
+                    id: 'top',
+                    primitive: 'box',
+                    slot: 'stone',
+                    size: ['width', 0.04, 'depth'],
+                    position: [0, sub('height', 0.02), 0],
+                },
+            ],
+        },
+        {
+            id: 'splashback',
+            label: 'Splashback',
+            count: 1,
+            shapes: [
+                {
+                    id: 'back',
+                    primitive: 'box',
+                    slot: 'stone',
+                    size: ['width', 'splashback', 0.025],
+                    position: [0, add('height', div('splashback', 2)), add(div('depth', -2), 0.0125)],
+                },
+            ],
+        },
+    ],
+    constraints: [],
+});
+export const experimentBriefs = [
+    {
+        id: 'shelf_open',
+        prompt: 'Create a freestanding open oak bookcase, 1.2 m wide and 1.8 m tall, with adjustable width, height, depth and shelf count. Expose frame and shelf material slots and shelf support surfaces.',
+    },
+    {
+        id: 'shelf_asymmetric',
+        prompt: 'Create an asymmetric low bookcase with a wide open compartment on the left and a narrow stack of shelves on the right. Expose overall width, height, depth and right shelf count. Use contrasting frame and back colors.',
+    },
+    {
+        id: 'bed_timber',
+        prompt: 'Create a timber platform bed with a mattress, a headboard and two pillows. Expose bed width, length, headboard height, pillow count and pillow size. Pillows must remain above the mattress when resized. Separate frame, bedding and pillow material slots.',
+    },
+    {
+        id: 'bed_upholstered',
+        prompt: 'Create an upholstered bed with a tall rounded headboard, a low base, mattress and three pillows. Expose bed width, length, headboard height and pillow count. Include independently adjustable pillow depth and separate material slots.',
+    },
+    {
+        id: 'bench',
+        prompt: 'Create a park bench with a slatted timber seat, backrest and two metal supports. Expose width, seat height, depth and slat count. Changing width must preserve support thickness. Separate timber and metal slots.',
+    },
+    {
+        id: 'divider',
+        prompt: 'Create a freestanding room divider with repeated vertical timber slats on a base. Expose width, height, depth and slat count. Keep every slat above the ground and evenly distributed when resized. Separate slat and base slots.',
+    },
+];

package/dist/procedural-items/index.d.ts

@@ -0,0 +1,10 @@
+export * from './fixtures.js';
+export * from './integration.js';
+export * from './library-colors.js';
+export * from './materials.js';
+export * from './node.js';
+export * from './placement.js';
+export * from './query.js';
+export * from './recipe.js';
+export * from './spatial.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/procedural-items/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procedural-items/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA"}

package/dist/procedural-items/index.js

@@ -0,0 +1,9 @@
+export * from './fixtures.js';
+export * from './integration.js';
+export * from './library-colors.js';
+export * from './materials.js';
+export * from './node.js';
+export * from './placement.js';
+export * from './query.js';
+export * from './recipe.js';
+export * from './spatial.js';

package/dist/procedural-items/integration.d.ts

@@ -0,0 +1,92 @@
+import { type QueryNodes } from './query.js';
+import type { Recipe, Vec3 } from './recipe.js';
+export declare function prepareProceduralPlacement(recipe: Recipe, nodes: QueryNodes, placement: {
+    parentId: string;
+    position: Vec3;
+    side?: 'front' | 'back';
+}): {
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: Record<string, unknown>;
+    id: `procedural-item_${string}`;
+    type: "procedural-item";
+    recipe: {
+        version: 1;
+        name: string;
+        description: string;
+        parameters: {
+            id: string;
+            label: string;
+            default: number;
+            min: number;
+            max: number;
+            step: number;
+            unit: "count" | "m" | "rad";
+            part?: string | undefined;
+            axis?: "x" | "y" | "z" | undefined;
+        }[];
+        slots: {
+            id: string;
+            label: string;
+            color: string;
+            finish?: "wood" | "glass" | "metal" | undefined;
+        }[];
+        parts: {
+            id: string;
+            label: string;
+            count: import("./recipe.js").Expr;
+            shapes: {
+                id: string;
+                primitive: "box" | "roundedBox" | "cylinder";
+                slot: string;
+                size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+                radius?: import("./recipe.js").Expr | undefined;
+                support?: boolean | undefined;
+            }[];
+        }[];
+        constraints: {
+            left: import("./recipe.js").Expr;
+            relation: "lte" | "gte";
+            right: import("./recipe.js").Expr;
+            message: string;
+        }[];
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            part?: string | undefined;
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        }[] | undefined;
+    };
+    parameters: Record<string, number>;
+    slots: Record<string, string>;
+    position: [number, number, number];
+    rotation: [number, number, number];
+    children: string[];
+    attachments: Record<string, string>;
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    wallId?: string | undefined;
+    side?: "front" | "back" | undefined;
+    supportSlabId?: string | undefined;
+};
+//# sourceMappingURL=integration.d.ts.map

package/dist/procedural-items/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../src/procedural-items/integration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAA+B,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAE5C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBzE"}

package/dist/procedural-items/integration.js

@@ -0,0 +1,19 @@
+import { ProceduralItemNode } from './node.js';
+import { validateProceduralRelations } from './query.js';
+export function prepareProceduralPlacement(recipe, nodes, placement) {
+    const parent = nodes[placement.parentId];
+    const hostType = recipe.mounting?.attachTo === 'ceiling' ? 'ceiling' : recipe.mounting ? 'wall' : 'level';
+    if (!parent || parent.type !== hostType)
+        throw new Error(`Choose a ${hostType} for this design`);
+    const node = ProceduralItemNode.parse({
+        recipe,
+        name: recipe.name,
+        parentId: parent.id,
+        position: placement.position,
+        ...(recipe.mounting?.attachTo === 'wall-side'
+            ? { wallId: parent.id, side: placement.side ?? 'front' }
+            : {}),
+    });
+    validateProceduralRelations(node, { ...nodes, [node.id]: node });
+    return node;
+}

package/dist/procedural-items/library-colors.d.ts

@@ -0,0 +1,56 @@
+import { type MaterialCatalogItem } from '../material-library.js';
+import type { ProceduralItemNode } from './node.js';
+import type { Recipe } from './recipe.js';
+type ProceduralFinish = NonNullable<Recipe['slots'][number]['finish']>;
+export declare const FINISH_LIBRARY_REFS: {
+    readonly glass: readonly [{
+        readonly ref: "library:preset-glass";
+        readonly color: "#87ceeb";
+    }];
+    readonly metal: readonly [{
+        readonly ref: "library:metal-steel";
+        readonly color: "#636363";
+    }, {
+        readonly ref: "library:metal-chrome";
+        readonly color: "#c8ccce";
+    }, {
+        readonly ref: "library:metal-brass";
+        readonly color: "#b08d57";
+    }, {
+        readonly ref: "library:metal-copper";
+        readonly color: "#cc845b";
+    }, {
+        readonly ref: "library:metal-polished";
+        readonly color: "#f3f3f3";
+    }, {
+        readonly ref: "library:preset-metal";
+        readonly color: "#c7ccd2";
+    }];
+    readonly wood: readonly [{
+        readonly ref: "library:wood-finewood27";
+        readonly color: "#a77440";
+    }, {
+        readonly ref: "library:wood-woodplank48";
+        readonly color: "#88654c";
+    }, {
+        readonly ref: "library:wood-hungarianparquet2";
+        readonly color: "#663020";
+    }, {
+        readonly ref: "library:wood-squareparquet21";
+        readonly color: "#3e220d";
+    }];
+};
+export declare function proceduralFinishLibraryColor(ref: string): string | undefined;
+export declare function resolveProceduralFinishRef(finish: ProceduralFinish, color: string): `library:${string}` | undefined;
+export type LibraryColorMatch = {
+    ref: `library:${string}`;
+    color: string;
+    name: string;
+    distance: number;
+};
+export declare function nearestLibraryColorRef(hex: string, catalog?: readonly MaterialCatalogItem[]): LibraryColorMatch | null;
+export declare function snapProceduralSlotsToLibrary(node: ProceduralItemNode, options?: {
+    keepOverrides: true;
+}): ProceduralItemNode['slots'];
+export {};
+//# sourceMappingURL=library-colors.d.ts.map

package/dist/procedural-items/library-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-colors.d.ts","sourceRoot":"","sources":["../../src/procedural-items/library-colors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,KAAK,gBAAgB,GAAG,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;AAItE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmB/B,CAAA;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI5E;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,MAAM,GACZ,WAAW,MAAM,EAAE,GAAG,SAAS,CAGjC;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,WAAW,MAAM,EAAE,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAiCD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,SAAS,mBAAmB,EAAqB,GACzD,iBAAiB,GAAG,IAAI,CAc1B;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kBAAkB,EACxB,OAAO,GAAE;IAAE,aAAa,EAAE,IAAI,CAAA;CAA4B,GACzD,kBAAkB,CAAC,OAAO,CAAC,CAU7B"}

package/dist/procedural-items/library-colors.js

@@ -0,0 +1,84 @@
+import { MATERIAL_CATALOG } from '../material-library.js';
+// Textured tones average source WebP RGB pixels (wood) or decoded KTX2 mip 0 (metal)
+// under apps/editor/public/material; flat finishes use their preset color.
+export const FINISH_LIBRARY_REFS = {
+    glass: [{ ref: 'library:preset-glass', color: '#87ceeb' }],
+    metal: [
+        { ref: 'library:metal-steel', color: '#636363' },
+        { ref: 'library:metal-chrome', color: '#c8ccce' },
+        { ref: 'library:metal-brass', color: '#b08d57' },
+        { ref: 'library:metal-copper', color: '#cc845b' },
+        { ref: 'library:metal-polished', color: '#f3f3f3' },
+        { ref: 'library:preset-metal', color: '#c7ccd2' },
+    ],
+    wood: [
+        { ref: 'library:wood-finewood27', color: '#a77440' },
+        { ref: 'library:wood-woodplank48', color: '#88654c' },
+        { ref: 'library:wood-hungarianparquet2', color: '#663020' },
+        { ref: 'library:wood-squareparquet21', color: '#3e220d' },
+    ],
+};
+export function proceduralFinishLibraryColor(ref) {
+    return Object.values(FINISH_LIBRARY_REFS)
+        .flat()
+        .find((preset) => preset.ref === ref)?.color;
+}
+export function resolveProceduralFinishRef(finish, color) {
+    return nearestColor(color, FINISH_LIBRARY_REFS[finish])
+        ?.ref;
+}
+function hexToLab(hex) {
+    if (!/^#[0-9a-f]{6}$/i.test(hex))
+        return null;
+    const linear = (offset) => {
+        const channel = Number.parseInt(hex.slice(offset, offset + 2), 16) / 255;
+        return channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+    };
+    const r = linear(1);
+    const g = linear(3);
+    const b = linear(5);
+    // sRGB uses D65; normalize XYZ by that white point before converting to Lab.
+    const f = (value) => value > (6 / 29) ** 3 ? Math.cbrt(value) : value / (3 * (6 / 29) ** 2) + 4 / 29;
+    const x = f((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047);
+    const y = f(0.2126729 * r + 0.7151522 * g + 0.072175 * b);
+    const z = f((0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883);
+    return [116 * y - 16, 500 * (x - y), 200 * (y - z)];
+}
+function nearestColor(hex, candidates) {
+    const lab = hexToLab(hex);
+    if (!lab)
+        return null;
+    let nearest = null;
+    for (const entry of candidates) {
+        const candidate = hexToLab(entry.color);
+        if (!candidate)
+            continue;
+        const distance = Math.hypot(lab[0] - candidate[0], lab[1] - candidate[1], lab[2] - candidate[2]);
+        if (!nearest || distance < nearest.distance)
+            nearest = { ...entry, distance };
+    }
+    return nearest;
+}
+export function nearestLibraryColorRef(hex, catalog = MATERIAL_CATALOG) {
+    return nearestColor(hex, catalog
+        // Flat swatches are in `colors` and have no populated maps, including non-albedo maps.
+        .filter((entry) => entry.category === 'colors' && !Object.values(entry.preset.maps).some(Boolean))
+        .map((entry) => ({
+        ref: `library:${entry.id}`,
+        color: entry.preset.mapProperties.color,
+        name: entry.label,
+    })));
+}
+export function snapProceduralSlotsToLibrary(node, options = { keepOverrides: true }) {
+    const slots = { ...node.slots };
+    for (const slot of node.recipe.slots) {
+        if (options.keepOverrides && Object.hasOwn(node.slots, slot.id))
+            continue;
+        const ref = slot.finish
+            ? resolveProceduralFinishRef(slot.finish, slot.color)
+            : nearestLibraryColorRef(slot.color)?.ref;
+        if (ref)
+            slots[slot.id] = ref;
+    }
+    return slots;
+}

package/dist/procedural-items/materials.d.ts

@@ -0,0 +1,5 @@
+import type { MaterialSchema } from '../schema/material.js';
+import { type SceneMaterial } from '../schema/scene-material.js';
+export declare function proceduralSlotColor(ref: string | undefined, fallback: string, materials: Record<string, SceneMaterial>): string;
+export declare function setProceduralMaterial(nodeId: string, slotId: string, ref?: string, material?: MaterialSchema): void;
+//# sourceMappingURL=materials.d.ts.map

package/dist/procedural-items/materials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/procedural-items/materials.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAA;AAOjC,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,UAUzC;AACD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,cAAc,QA4B1B"}