@treasuryspatial/viewer-kit 0.2.45 → 0.2.50

package/dist/materials/architectural.d.ts

@@ -1,7 +1,7 @@
 import * as THREE from "three";
-import type { MaterialId, MaterialsConfig, SurfaceMaterialConfig } from "./types";
+import type { MaterialApplicationPolicy, MaterialId, MaterialSurfaceRole, MaterialsConfig, SurfaceMaterialConfig } from "./types";
 export declare const setTextureBaseUrl: (baseUrl?: string) => void;
-export declare function buildSurfaceMaterial(surface: "walls" | "floor" | "ceiling", config: SurfaceMaterialConfig): THREE.MeshStandardMaterial;
+export declare function buildSurfaceMaterial(surface: MaterialSurfaceRole | string, config: SurfaceMaterialConfig): THREE.MeshStandardMaterial;
 export declare function buildCatalogMaterial(materialId: MaterialId, overrides?: Partial<SurfaceMaterialConfig>): THREE.MeshStandardMaterial;
-export declare function applyMaterialsToGroup(group: THREE.Group, materialsConfig?: MaterialsConfig | null, floorLevel?: number, ceilingHeight?: number): void;
+export declare function applyMaterialsToGroup(group: THREE.Group, materialsConfig?: MaterialsConfig | null, floorLevel?: number, ceilingHeight?: number, policy?: MaterialApplicationPolicy): void;
 //# sourceMappingURL=architectural.d.ts.map

package/dist/materials/architectural.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"architectural.d.ts","sourceRoot":"","sources":["../../src/materials/architectural.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAalF,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,SAMjD,CAAC;AA0GF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,qBAAqB,8BAEzG;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,8BAiBtG;AA4BD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CAgCN"}
+{"version":3,"file":"architectural.d.ts","sourceRoot":"","sources":["../../src/materials/architectural.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EACV,yBAAyB,EACzB,UAAU,EACV,mBAAmB,EACnB,eAAe,EAEf,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAcjB,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,SAMjD,CAAC;AAsHF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,EAAE,MAAM,EAAE,qBAAqB,8BAExG;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,8BAiBtG;AAqND,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,yBAA8B,GACrC,IAAI,CA6JN"}

package/dist/materials/architectural.js

@@ -4,6 +4,7 @@ import { getRenderMaterialMetadata } from "./renderMetadata";
 const clamp01 = (value) => Math.min(Math.max(value, 0), 1);
 const colorFromRGB = (rgb) => new THREE.Color(rgb.r / 255, rgb.g / 255, rgb.b / 255);
 const textureLoader = new THREE.TextureLoader();
+textureLoader.setCrossOrigin("anonymous");
 const textureCache = new Map();
 let textureBaseUrl = "";
 export const setTextureBaseUrl = (baseUrl) => {
@@ -112,6 +113,16 @@ const buildMaterial = (surface, config) => {
     material.name = `${surface}-material`;
     return material;
 };
+const buildFallbackMaterial = () => new THREE.MeshStandardMaterial({
+    color: new THREE.Color("#d6d9e0"),
+    roughness: 0.72,
+    metalness: 0.02,
+    emissive: new THREE.Color("#eef1f7"),
+    emissiveIntensity: 0.02,
+    depthWrite: true,
+    depthTest: true,
+    side: THREE.DoubleSide,
+});
 export function buildSurfaceMaterial(surface, config) {
     return buildMaterial(surface, config);
 }
@@ -133,55 +144,302 @@ export function buildCatalogMaterial(materialId, overrides) {
     };
     return buildMaterial(materialId, config);
 }
-const classifySurfaceWorld = (bboxWorld, floorY, ceilingY) => {
-    const dx = bboxWorld.max.x - bboxWorld.min.x;
-    const dy = bboxWorld.max.y - bboxWorld.min.y;
-    const dz = bboxWorld.max.z - bboxWorld.min.z;
-    const centerY = (bboxWorld.min.y + bboxWorld.max.y) / 2;
-    const midY = (floorY + ceilingY) / 2;
-    const isBroadHorizontal = dy <= 0.35 && dx >= 0.8 && dz >= 0.8;
-    if (isBroadHorizontal) {
-        return centerY <= midY ? "floor" : "ceiling";
-    }
-    const isSlabLike = dy <= 1.0 && dx >= 0.8 && dz >= 0.8;
-    if (isSlabLike) {
-        if (bboxWorld.max.y <= floorY + 0.6)
-            return "floor";
-        if (bboxWorld.min.y >= ceilingY - 0.6)
-            return "ceiling";
-        return centerY <= midY ? "floor" : "ceiling";
-    }
-    return "walls";
+const CORE_MATERIAL_SURFACES = ["walls", "floor", "ceiling"];
+const CORE_SURFACE_MATERIAL_ROLES = {
+    walls: "walls",
+    floor: "floor",
+    ceiling: "ceiling",
+    roof: "ceiling",
 };
-export function applyMaterialsToGroup(group, materialsConfig, floorLevel, ceilingHeight) {
+const normalizeTagValue = (value) => {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+};
+const hasRuleValues = (values) => Array.isArray(values) && values.some((value) => Boolean(normalizeTagValue(value)));
+const matchesRuleValues = (candidate, values) => {
+    if (!hasRuleValues(values))
+        return true;
+    if (!candidate)
+        return false;
+    return (values ?? []).some((value) => normalizeTagValue(value) === candidate);
+};
+const isCatalogMaterialId = (value) => Boolean(value && findMaterial(value));
+const buildSurfaceRegistry = (policy) => {
+    const registry = new Map();
+    if (policy.includeCoreSurfaceRoles ?? true) {
+        Object.entries(CORE_SURFACE_MATERIAL_ROLES).forEach(([surfaceId, role]) => {
+            registry.set(surfaceId, {
+                id: surfaceId,
+                parentId: surfaceId !== role ? role : undefined,
+            });
+        });
+    }
+    (policy.surfaceDefinitions ?? []).forEach((surface) => {
+        const normalized = normalizeTagValue(surface.id);
+        if (!normalized || registry.has(normalized))
+            return;
+        registry.set(normalized, {
+            id: surface.id,
+            parentId: surface.parentId ? normalizeTagValue(surface.parentId) ?? undefined : undefined,
+        });
+    });
+    return registry;
+};
+const mappingHasCriteria = (mapping) => hasRuleValues(mapping.surfaceIds) ||
+    hasRuleValues(mapping.classes) ||
+    hasRuleValues(mapping.subclasses) ||
+    hasRuleValues(mapping.roles) ||
+    hasRuleValues(mapping.layers) ||
+    hasRuleValues(mapping.materials);
+const describeSurfaceMappingFailure = (candidate) => {
+    const parts = [
+        candidate.surface ? `surface='${candidate.surface}'` : null,
+        candidate.className ? `class='${candidate.className}'` : null,
+        candidate.subclassName ? `subclass='${candidate.subclassName}'` : null,
+    ].filter((value) => Boolean(value));
+    return parts.join(", ");
+};
+const resolveSurfaceFromTags = (userData, policy) => {
+    const registry = buildSurfaceRegistry(policy);
+    const candidate = {
+        surface: normalizeTagValue(userData?.surface),
+        className: normalizeTagValue(userData?.class),
+        subclassName: normalizeTagValue(userData?.subclass),
+        role: normalizeTagValue(userData?.role),
+        layer: normalizeTagValue(userData?.layer),
+        material: normalizeTagValue(userData?.material),
+    };
+    if (candidate.surface) {
+        const direct = registry.get(candidate.surface);
+        if (direct) {
+            return { surfaceId: direct.id, parentSurfaceId: direct.parentId ?? null, unresolvedMapping: null };
+        }
+        if (isCatalogMaterialId(candidate.surface)) {
+            return { surfaceId: null, parentSurfaceId: null, unresolvedMapping: null };
+        }
+    }
+    const mappedSurface = (policy.surfaceMappings ?? []).find((mapping) => mappingHasCriteria(mapping) &&
+        matchesRuleValues(candidate.surface, mapping.surfaceIds) &&
+        matchesRuleValues(candidate.className, mapping.classes) &&
+        matchesRuleValues(candidate.subclassName, mapping.subclasses) &&
+        matchesRuleValues(candidate.role, mapping.roles) &&
+        matchesRuleValues(candidate.layer, mapping.layers) &&
+        matchesRuleValues(candidate.material, mapping.materials));
+    if (mappedSurface?.surfaceId) {
+        const normalizedMappedSurface = normalizeTagValue(mappedSurface.surfaceId);
+        const registeredSurface = normalizedMappedSurface ? registry.get(normalizedMappedSurface) : null;
+        return {
+            surfaceId: registeredSurface?.id ?? mappedSurface.surfaceId,
+            parentSurfaceId: registeredSurface?.parentId ?? null,
+            unresolvedMapping: null,
+        };
+    }
+    const directClassMatch = candidate.className ? registry.get(candidate.className) : null;
+    if (directClassMatch) {
+        return { surfaceId: directClassMatch.id, parentSurfaceId: directClassMatch.parentId ?? null, unresolvedMapping: null };
+    }
+    const directSubclassMatch = candidate.subclassName ? registry.get(candidate.subclassName) : null;
+    if (directSubclassMatch) {
+        return { surfaceId: directSubclassMatch.id, parentSurfaceId: directSubclassMatch.parentId ?? null, unresolvedMapping: null };
+    }
+    if (candidate.surface || candidate.className || candidate.subclassName) {
+        return {
+            surfaceId: null,
+            parentSurfaceId: null,
+            unresolvedMapping: describeSurfaceMappingFailure(candidate),
+        };
+    }
+    return { surfaceId: null, parentSurfaceId: null, unresolvedMapping: null };
+};
+const lookupSurfaceMaterial = (materialSet, surfaceId, parentSurfaceId, requiredSurfaceBindingIds, policy) => {
+    if (!materialSet || !surfaceId)
+        return null;
+    const honorCoreSurfaceMaterials = policy.honorCoreSurfaceMaterials ?? true;
+    const honorSurfaceParentMaterials = policy.honorSurfaceParentMaterials ?? true;
+    const normalizedSurfaceId = normalizeTagValue(surfaceId);
+    // Manifest-authored exact surface materials must win before core parent defaults.
+    const exactSurfaceMaterial = materialSet.surfaces[surfaceId] ?? (normalizedSurfaceId ? materialSet.surfaces[normalizedSurfaceId] : null) ?? null;
+    if (exactSurfaceMaterial || (normalizedSurfaceId && requiredSurfaceBindingIds.has(normalizedSurfaceId))) {
+        return exactSurfaceMaterial;
+    }
+    const coreSurfaceRole = normalizedSurfaceId ? CORE_SURFACE_MATERIAL_ROLES[normalizedSurfaceId] : undefined;
+    if (honorCoreSurfaceMaterials && coreSurfaceRole) {
+        return materialSet[coreSurfaceRole];
+    }
+    if (!honorSurfaceParentMaterials) {
+        return null;
+    }
+    const normalizedParentSurfaceId = normalizeTagValue(parentSurfaceId);
+    const exactParentSurfaceMaterial = parentSurfaceId
+        ? materialSet.surfaces[parentSurfaceId] ??
+            (normalizedParentSurfaceId ? materialSet.surfaces[normalizedParentSurfaceId] : null) ??
+            null
+        : null;
+    if (exactParentSurfaceMaterial) {
+        return exactParentSurfaceMaterial;
+    }
+    return null;
+};
+const resolveShadowPolicy = (surface) => {
+    const normalizedSurface = surface?.trim().toLowerCase() ?? "";
+    if (normalizedSurface === "plaster" ||
+        normalizedSurface === "dormer-body" ||
+        normalizedSurface === "plaster_flat" ||
+        normalizedSurface === "walls") {
+        return { cast: false, receive: true };
+    }
+    if (normalizedSurface === "zinc" ||
+        normalizedSurface === "membrane" ||
+        normalizedSurface === "terrace-deck" ||
+        normalizedSurface === "dormer-roof") {
+        return { cast: true, receive: true };
+    }
+    if (normalizedSurface.includes("glass") || normalizedSurface.includes("glazing")) {
+        return { cast: false, receive: false };
+    }
+    if (normalizedSurface === "floor" || normalizedSurface === "ceiling") {
+        return { cast: false, receive: true };
+    }
+    return { cast: true, receive: true };
+};
+export function applyMaterialsToGroup(group, materialsConfig, floorLevel, ceilingHeight, policy = {}) {
     if (!group || typeof group.traverse !== "function")
         return;
-    const floorY = typeof floorLevel === "number" ? floorLevel : 0;
-    const ceilingY = typeof ceilingHeight === "number" ? floorY + ceilingHeight : undefined;
+    void floorLevel;
+    void ceilingHeight;
     const materialSet = materialsConfig
         ? {
-            walls: buildSurfaceMaterial("walls", materialsConfig.walls),
-            floor: buildSurfaceMaterial("floor", materialsConfig.floor),
-            ceiling: buildSurfaceMaterial("ceiling", materialsConfig.ceiling),
+            walls: materialsConfig.walls ? buildSurfaceMaterial("walls", materialsConfig.walls) : null,
+            floor: materialsConfig.floor ? buildSurfaceMaterial("floor", materialsConfig.floor) : null,
+            ceiling: materialsConfig.ceiling ? buildSurfaceMaterial("ceiling", materialsConfig.ceiling) : null,
+            surfaces: Object.fromEntries(Object.entries(materialsConfig.surfaces ?? {}).map(([surfaceId, config]) => [
+                surfaceId,
+                buildSurfaceMaterial(surfaceId, config),
+            ])),
         }
         : null;
     group.updateMatrixWorld(true);
+    const honorObjectColor = policy.honorObjectColor ?? true;
+    const requiredSurfaceBindingIds = new Set((policy.requiredSurfaceBindingIds ?? []).map((surfaceId) => normalizeTagValue(surfaceId)).filter(Boolean));
+    const defaultSurfaceMaterial = policy.defaultSurfaceMaterial
+        ? buildSurfaceMaterial("default", policy.defaultSurfaceMaterial)
+        : null;
+    const resolveMappedSurfaceMaterial = (surfaceId, parentSurfaceId) => {
+        const mappedSurfaceMaterial = lookupSurfaceMaterial(materialSet, surfaceId, parentSurfaceId, requiredSurfaceBindingIds, policy);
+        if (mappedSurfaceMaterial)
+            return mappedSurfaceMaterial;
+        const normalizedSurfaceId = normalizeTagValue(surfaceId);
+        if (defaultSurfaceMaterial && normalizedSurfaceId && !requiredSurfaceBindingIds.has(normalizedSurfaceId)) {
+            return defaultSurfaceMaterial;
+        }
+        return null;
+    };
     group.traverse((child) => {
         if (!child?.isMesh)
             return;
-        child.castShadow = true;
-        child.receiveShadow = true;
-        child.geometry.computeBoundingBox();
-        const bbox = child.geometry.boundingBox;
-        const taggedMaterialId = typeof child.userData?.material === "string" ? child.userData.material : null;
-        if (taggedMaterialId && findMaterial(taggedMaterialId)) {
-            child.material = buildCatalogMaterial(taggedMaterialId);
+        let resolvedSurface = null;
+        const objectColor = typeof child.userData?.objectColor === "string" ? child.userData.objectColor.trim() : null;
+        let materialApplied = false;
+        let pendingSurfaceFailure = null;
+        const taggedSurface = resolveSurfaceFromTags(child.userData, policy);
+        const clearSurfaceDiagnostics = () => {
+            if (!child.userData)
+                return;
+            delete child.userData.unresolvedSurfaceType;
+            delete child.userData.unresolvedSurfaceMapping;
+        };
+        const applyFallbackSurfaceMaterial = () => {
+            child.material = defaultSurfaceMaterial ? defaultSurfaceMaterial.clone() : buildFallbackMaterial();
+            materialApplied = true;
+        };
+        const applyContractFailure = (detail) => {
+            child.userData = {
+                ...child.userData,
+                unresolvedSurfaceMapping: detail,
+            };
+            applyFallbackSurfaceMaterial();
+        };
+        const tryApplySurfaceBinding = () => {
+            if (taggedSurface.surfaceId) {
+                const mappedSurfaceMaterial = resolveMappedSurfaceMaterial(taggedSurface.surfaceId, taggedSurface.parentSurfaceId);
+                child.userData = {
+                    ...child.userData,
+                    surfaceType: taggedSurface.surfaceId,
+                };
+                resolvedSurface = taggedSurface.surfaceId;
+                if (mappedSurfaceMaterial) {
+                    clearSurfaceDiagnostics();
+                    child.material = mappedSurfaceMaterial.clone();
+                    materialApplied = true;
+                    return;
+                }
+                child.userData = {
+                    ...child.userData,
+                    unresolvedSurfaceType: taggedSurface.surfaceId,
+                };
+                pendingSurfaceFailure = `surface '${taggedSurface.surfaceId}' has no material binding`;
+                return;
+            }
+            if (taggedSurface.unresolvedMapping) {
+                child.userData = {
+                    ...child.userData,
+                    unresolvedSurfaceMapping: taggedSurface.unresolvedMapping,
+                };
+                pendingSurfaceFailure = taggedSurface.unresolvedMapping;
+                return;
+            }
+            if (objectColor && honorObjectColor) {
+                const parsedHex = Number.parseInt(objectColor.replace(/^#/, ""), 16);
+                if (Number.isFinite(parsedHex)) {
+                    clearSurfaceDiagnostics();
+                    child.material = new THREE.MeshStandardMaterial({
+                        color: parsedHex,
+                        roughness: 0.65,
+                        metalness: 0.1,
+                    });
+                    materialApplied = true;
+                    return;
+                }
+            }
+            pendingSurfaceFailure = "missing explicit surface classification";
+        };
+        if (!materialApplied && taggedSurface.surfaceId) {
+            const mappedSurfaceMaterial = resolveMappedSurfaceMaterial(taggedSurface.surfaceId, taggedSurface.parentSurfaceId);
+            child.userData = {
+                ...child.userData,
+                surfaceType: taggedSurface.surfaceId,
+            };
+            resolvedSurface = taggedSurface.surfaceId;
+            if (mappedSurfaceMaterial) {
+                clearSurfaceDiagnostics();
+                child.material = mappedSurfaceMaterial.clone();
+                materialApplied = true;
+            }
+            else {
+                pendingSurfaceFailure = `surface '${taggedSurface.surfaceId}' has no material binding`;
+            }
+        }
+        else if (!materialApplied && taggedSurface.unresolvedMapping) {
+            child.userData = {
+                ...child.userData,
+                unresolvedSurfaceMapping: taggedSurface.unresolvedMapping,
+            };
+            pendingSurfaceFailure = taggedSurface.unresolvedMapping;
+        }
+        if (!materialApplied) {
+            tryApplySurfaceBinding();
+        }
+        if (!materialApplied) {
+            applyContractFailure(pendingSurfaceFailure ?? "missing explicit surface classification");
         }
-        else if (bbox && materialSet && typeof ceilingY === "number") {
-            const bboxWorld = bbox.clone().applyMatrix4(child.matrixWorld);
-            const surface = classifySurfaceWorld(bboxWorld, floorY, ceilingY);
-            child.material = materialSet[surface].clone();
+        const shadowPolicy = resolveShadowPolicy(resolvedSurface);
+        child.castShadow = shadowPolicy.cast;
+        child.receiveShadow = shadowPolicy.receive;
+        const normal = child.geometry.getAttribute("normal");
+        if (!normal || normal.count === 0) {
+            child.geometry.computeVertexNormals();
         }
-        child.geometry.computeVertexNormals();
     });
 }

package/dist/materials/catalogue-data.d.ts

@@ -1,6 +1,21 @@
 export declare const MATERIAL_CATALOGUE: {
     readonly version: 1;
     readonly materials: readonly [{
+        readonly materialId: "plaster_flat";
+        readonly label: "flat mineral plaster";
+        readonly category: "walls";
+        readonly baseline: {
+            readonly color: "#F3F1EC";
+            readonly finish: "matte";
+        };
+        readonly pbr: {
+            readonly baseColor: "#F5F3EE";
+            readonly roughness: 0.72;
+            readonly metalness: 0;
+            readonly emissive: "#FFFFFF";
+            readonly emissiveIntensity: 0.02;
+        };
+    }, {
         readonly materialId: "white_wall";
         readonly label: "white plaster wall";
         readonly category: "walls";

package/dist/materials/catalogue-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalogue-data.d.ts","sourceRoot":"","sources":["../../src/materials/catalogue-data.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6JrB,CAAC"}
+{"version":3,"file":"catalogue-data.d.ts","sourceRoot":"","sources":["../../src/materials/catalogue-data.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6KrB,CAAC"}

package/dist/materials/catalogue-data.js

@@ -1,6 +1,22 @@
 export const MATERIAL_CATALOGUE = {
     "version": 1,
     "materials": [
+        {
+            "materialId": "plaster_flat",
+            "label": "flat mineral plaster",
+            "category": "walls",
+            "baseline": {
+                "color": "#F3F1EC",
+                "finish": "matte"
+            },
+            "pbr": {
+                "baseColor": "#F5F3EE",
+                "roughness": 0.72,
+                "metalness": 0.0,
+                "emissive": "#FFFFFF",
+                "emissiveIntensity": 0.02
+            }
+        },
         {
             "materialId": "white_wall",
             "label": "white plaster wall",

package/dist/materials/presets.d.ts

@@ -1,21 +1,28 @@
-import type { MaterialId, MaterialsConfig, SurfaceMaterialConfig } from "./types";
-export type MaterialSlotReference = {
+import type { MaterialDefinition, MaterialId, MaterialSurfaceConfigMap, MaterialsConfig, SurfaceMaterialConfig } from "./types";
+export type MaterialBindingReference = {
     catalogId: MaterialId;
     overrides?: Partial<SurfaceMaterialConfig>;
 };
+export type MaterialBindingReferenceMap = Record<string, MaterialBindingReference>;
+export type MaterialDefinitionLookup = ReadonlyArray<MaterialDefinition> | ReadonlyMap<string, MaterialDefinition>;
 export type MaterialPresetDefinition = {
     id: string;
     label: string;
     materials: {
-        walls: MaterialSlotReference;
-        floor: MaterialSlotReference;
-        ceiling: MaterialSlotReference;
+        walls: MaterialBindingReference;
+        floor: MaterialBindingReference;
+        ceiling: MaterialBindingReference;
+        surfaces?: MaterialBindingReferenceMap;
     };
 };
-export declare const BASELINE_MATERIAL_PRESET_ID = "calenv-baseline";
+export declare const ARCHITECTURAL_WHITE_MATERIAL_PRESET_ID = "architectural-white";
+export declare const MONOCHROME_CLAY_MATERIAL_PRESET_ID = "monochrome-clay";
+export declare const UPLOAD_VISIBLE_MATERIAL_PRESET_ID = "upload-visible";
 export declare const MATERIAL_PRESET_DATA: Record<string, MaterialPresetDefinition>;
-export declare function resolveMaterialSlot(slot: MaterialSlotReference): SurfaceMaterialConfig;
-export declare function resolveMaterialPresetMaterials(preset: MaterialPresetDefinition): MaterialsConfig;
+export declare const hasMaterialDefinition: (materialId: MaterialId, materialDefinitions?: MaterialDefinitionLookup) => boolean;
+export declare function resolveMaterialBinding(binding: MaterialBindingReference, materialDefinitions?: MaterialDefinitionLookup): SurfaceMaterialConfig;
+export declare function resolveMaterialSurfaceMap(surfaces?: MaterialBindingReferenceMap | null, materialDefinitions?: MaterialDefinitionLookup): MaterialSurfaceConfigMap | undefined;
+export declare function resolveMaterialPresetMaterials(preset: MaterialPresetDefinition, materialDefinitions?: MaterialDefinitionLookup): MaterialsConfig;
 export declare function listMaterialPresets(): MaterialPresetDefinition[];
 export declare function getMaterialPreset(id: string): MaterialPresetDefinition;
 //# sourceMappingURL=presets.d.ts.map

package/dist/materials/presets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/materials/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAGlF,MAAM,MAAM,qBAAqB,GAAG;IAClC,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE;QACT,KAAK,EAAE,qBAAqB,CAAC;QAC7B,KAAK,EAAE,qBAAqB,CAAC;QAC7B,OAAO,EAAE,qBAAqB,CAAC;KAChC,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,2BAA2B,oBAAoB,CAAC;AAO7D,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAuKzE,CAAC;AA+BF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,qBAAqB,GAAG,qBAAqB,CAGtF;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,wBAAwB,GAAG,eAAe,CAMhG;AAED,wBAAgB,mBAAmB,IAAI,wBAAwB,EAAE,CAEhE;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,CAMtE"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/materials/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,UAAU,EACV,wBAAwB,EACxB,eAAe,EACf,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,UAAU,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;AACnF,MAAM,MAAM,wBAAwB,GAAG,aAAa,CAAC,kBAAkB,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEnH,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE;QACT,KAAK,EAAE,wBAAwB,CAAC;QAChC,KAAK,EAAE,wBAAwB,CAAC;QAChC,OAAO,EAAE,wBAAwB,CAAC;QAClC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;KACxC,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,sCAAsC,wBAAwB,CAAC;AAC5E,eAAO,MAAM,kCAAkC,oBAAoB,CAAC;AACpE,eAAO,MAAM,iCAAiC,mBAAmB,CAAC;AAOlE,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CA0OzE,CAAC;AAsBF,eAAO,MAAM,qBAAqB,GAAI,YAAY,UAAU,EAAE,sBAAsB,wBAAwB,YAC1C,CAAC;AAmBnE,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,wBAAwB,EACjC,mBAAmB,CAAC,EAAE,wBAAwB,GAC7C,qBAAqB,CAGvB;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,CAAC,EAAE,2BAA2B,GAAG,IAAI,EAC7C,mBAAmB,CAAC,EAAE,wBAAwB,GAC7C,wBAAwB,GAAG,SAAS,CAMtC;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,wBAAwB,EAChC,mBAAmB,CAAC,EAAE,wBAAwB,GAC7C,eAAe,CA2BjB;AAED,wBAAgB,mBAAmB,IAAI,wBAAwB,EAAE,CAEhE;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,CAMtE"}