@pascal-app/viewer 0.6.0 → 0.7.0

package/dist/systems/fence/fence-system.d.ts

@@ -0,0 +1,2 @@
+export declare const FenceSystem: () => null;
+//# sourceMappingURL=fence-system.d.ts.map

package/dist/systems/fence/fence-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-system.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-system.tsx"],"names":[],"mappings":"AA6QA,eAAO,MAAM,WAAW,YAiBvB,CAAA"}

package/dist/systems/fence/fence-system.js

@@ -0,0 +1,185 @@
+import { useFrame } from '@react-three/fiber';
+import { getWallCurveFrameAt, getWallCurveLength, sceneRegistry, useScene, } from '@pascal-app/core';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+const MIN_CURVE_SEGMENT_LENGTH = 0.18;
+function createFencePartGeometry(part) {
+    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    geometry.scale(part.scale[0], part.scale[1], part.scale[2]);
+    if (part.rotationY) {
+        geometry.rotateY(part.rotationY);
+    }
+    geometry.translate(part.position[0], part.position[1], part.position[2]);
+    applyFenceUVs(geometry);
+    return geometry;
+}
+function getFencePointAt(fence, t) {
+    const frame = getWallCurveFrameAt(fence, t);
+    return {
+        point: frame.point,
+        tangentAngle: Math.atan2(frame.tangent.y, frame.tangent.x),
+    };
+}
+function createStraightFenceSpanPart(start, end, centerY, height, depth) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length <= 1e-4) {
+        return null;
+    }
+    return {
+        position: [(start[0] + end[0]) / 2, centerY, (start[1] + end[1]) / 2],
+        rotationY: -Math.atan2(dz, dx),
+        scale: [length, height, depth],
+    };
+}
+function createFenceCurveSpanParts(fence, startT, endT, centerY, height, depth) {
+    const parts = [];
+    const frameCount = Math.max(1, Math.ceil((getWallCurveLength(fence) * Math.max(1e-4, endT - startT)) / MIN_CURVE_SEGMENT_LENGTH));
+    let previous = getFencePointAt(fence, startT);
+    for (let index = 1; index <= frameCount; index += 1) {
+        const t = startT + (endT - startT) * (index / frameCount);
+        const current = getFencePointAt(fence, t);
+        const segment = createStraightFenceSpanPart([previous.point.x, previous.point.y], [current.point.x, current.point.y], centerY, height, depth);
+        if (segment) {
+            parts.push(segment);
+        }
+        previous = current;
+    }
+    return parts;
+}
+function applyFenceUVs(geometry) {
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    if (!(position && normal))
+        return;
+    const uvs = new Float32Array(position.count * 2);
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < position.count; index += 1) {
+        minX = Math.min(minX, position.getX(index));
+        minY = Math.min(minY, position.getY(index));
+        minZ = Math.min(minZ, position.getZ(index));
+    }
+    for (let index = 0; index < position.count; index += 1) {
+        const px = position.getX(index);
+        const py = position.getY(index);
+        const pz = position.getZ(index);
+        const nx = Math.abs(normal.getX(index));
+        const ny = Math.abs(normal.getY(index));
+        const nz = Math.abs(normal.getZ(index));
+        let u = 0;
+        let v = 0;
+        if (ny >= nx && ny >= nz) {
+            u = px - minX;
+            v = pz - minZ;
+        }
+        else if (nx >= nz) {
+            u = pz - minZ;
+            v = py - minY;
+        }
+        else {
+            u = px - minX;
+            v = py - minY;
+        }
+        uvs[index * 2] = u;
+        uvs[index * 2 + 1] = v;
+    }
+    geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geometry.setAttribute('uv2', new THREE.Float32BufferAttribute(uvs.slice(), 2));
+}
+function getStyleDefaults(style) {
+    if (style === 'privacy') {
+        return { spacingFactor: 0.42, postFactor: 1.35, baseFactor: 1.2, topFactor: 1.2 };
+    }
+    if (style === 'rail') {
+        return { spacingFactor: 0.68, postFactor: 0.8, baseFactor: 0.85, topFactor: 0.85 };
+    }
+    return { spacingFactor: 0.3, postFactor: 0.55, baseFactor: 1, topFactor: 0.75 };
+}
+function createFenceParts(fence) {
+    const parts = [];
+    const length = Math.max(getWallCurveLength(fence), 0.01);
+    const panelDepth = Math.max(fence.thickness, 0.03);
+    const clearance = Math.max(fence.groundClearance, 0);
+    const styleDefaults = getStyleDefaults(fence.style);
+    const baseHeight = Math.max(fence.baseHeight * styleDefaults.baseFactor, 0.04);
+    const topRailHeight = Math.max(fence.topRailHeight * styleDefaults.topFactor, 0.01);
+    const verticalHeight = Math.max(fence.height - baseHeight - topRailHeight, 0.08);
+    const postWidth = Math.max(fence.postSize * styleDefaults.postFactor, 0.01);
+    const spacing = Math.max(fence.postSpacing * styleDefaults.spacingFactor, postWidth * 1.2);
+    const edgeInset = Math.max(fence.edgeInset ?? 0.015, 0.005);
+    const isFloating = fence.baseStyle === 'floating';
+    const baseY = isFloating ? clearance : 0;
+    const effectiveBaseHeight = baseHeight;
+    const startInsetT = Math.min(0.499, edgeInset / length);
+    const endInsetT = Math.max(0.501, 1 - edgeInset / length);
+    if (!isFloating) {
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight / 2, effectiveBaseHeight, panelDepth * 1.05));
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight * 0.15, topRailHeight * 0.8, panelDepth * 0.35));
+    }
+    const count = Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1);
+    const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
+    for (let index = 0; index < count; index += 1) {
+        const t = count === 1 ? 0.5 : startInsetT + (endInsetT - startInsetT) * (index / (count - 1));
+        const frame = getFencePointAt(fence, t);
+        const isEdgePost = index === 0 || index === count - 1;
+        const postHeight = isFloating && isEdgePost
+            ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
+            : verticalHeight;
+        const postY = isFloating && isEdgePost ? postHeight / 2 : verticalY;
+        parts.push({
+            position: [frame.point.x, postY, frame.point.y],
+            rotationY: -frame.tangentAngle,
+            scale: [postWidth, postHeight, Math.max(panelDepth * 0.35, 0.012)],
+        });
+    }
+    parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+    if (isFloating) {
+        parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + topRailHeight / 2, topRailHeight, Math.max(panelDepth * 0.55, 0.018)));
+    }
+    return parts;
+}
+function generateFenceGeometry(fence) {
+    const parts = createFenceParts(fence);
+    const geometries = parts.map(createFencePartGeometry);
+    const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
+    geometries.forEach((geometry) => geometry.dispose());
+    const mergedUv = merged.getAttribute('uv');
+    if (mergedUv) {
+        merged.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(mergedUv.array), 2));
+    }
+    merged.computeVertexNormals();
+    return merged;
+}
+function updateFenceGeometry(fenceId) {
+    const node = useScene.getState().nodes[fenceId];
+    if (!node || node.type !== 'fence')
+        return;
+    const mesh = sceneRegistry.nodes.get(fenceId);
+    if (!mesh)
+        return;
+    const newGeometry = generateFenceGeometry(node);
+    mesh.geometry.dispose();
+    mesh.geometry = newGeometry;
+    mesh.position.set(0, 0, 0);
+    mesh.rotation.set(0, 0, 0);
+}
+export const FenceSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'fence')
+                return;
+            updateFenceGeometry(id);
+            clearDirty(id);
+        });
+    }, 4);
+    return null;
+};

package/dist/systems/item/item-system.d.ts

@@ -0,0 +1,2 @@
+export declare const ItemSystem: () => null;
+//# sourceMappingURL=item-system.d.ts.map

package/dist/systems/item/item-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item/item-system.tsx"],"names":[],"mappings":"AAiBA,eAAO,MAAM,UAAU,YA6CtB,CAAA"}

package/dist/systems/item/item-system.js

@@ -0,0 +1,44 @@
+import { useFrame } from '@react-three/fiber';
+import { getScaledDimensions, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+// ============================================================================
+// ITEM SYSTEM
+// ============================================================================
+export const ItemSystem = () => {
+    const dirtyNodes = useScene((state) => state.dirtyNodes);
+    const clearDirty = useScene((state) => state.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node || node.type !== 'item')
+                return;
+            const item = node;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (!mesh)
+                return;
+            if (item.asset.attachTo === 'wall-side') {
+                // Wall-attached item: offset Z by half the parent wall's thickness
+                const parentWall = item.parentId ? nodes[item.parentId] : undefined;
+                if (parentWall && parentWall.type === 'wall') {
+                    const wallThickness = parentWall.thickness ?? 0.1;
+                    const side = item.side === 'front' ? 1 : -1;
+                    mesh.position.z = (wallThickness / 2) * side;
+                }
+            }
+            else if (!item.asset.attachTo) {
+                // If parented to another item (surface placement), R3F handles positioning via the hierarchy
+                const parentNode = item.parentId ? nodes[item.parentId] : undefined;
+                if (parentNode?.type !== 'item') {
+                    // Floor item: elevate by slab height (using full footprint overlap)
+                    const levelId = resolveLevelId(item, nodes);
+                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, getScaledDimensions(item), item.rotation);
+                    mesh.position.y = slabElevation + item.position[1];
+                }
+            }
+            clearDirty(id);
+        });
+    }, 2);
+    return null;
+};

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.d.ts

@@ -0,0 +1,14 @@
+import type { Object3D } from 'three';
+type Point = {
+    x: number;
+    y: number;
+};
+export type MeshLocalBounds = {
+    min: [number, number, number];
+    max: [number, number, number];
+};
+/** Plan footprint in the item root's horizontal (x, z) plane — stored as floorplan polygon. */
+export declare function computePlanFootprintPolygonLocal(object: Object3D): Point[];
+export declare function computeMeshLocalBoundsFromObject(object: Object3D): MeshLocalBounds | null;
+export {};
+//# sourceMappingURL=compute-item-mesh-metadata.d.ts.map

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-item-mesh-metadata.d.ts","sourceRoot":"","sources":["../../../src/systems/item-mesh-metadata/compute-item-mesh-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAGrC,KAAK,KAAK,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAErC,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,QAAQ,GAAG,KAAK,EAAE,CA0E1E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI,CAmDzF"}

package/dist/systems/item-mesh-metadata/compute-item-mesh-metadata.js

@@ -0,0 +1,155 @@
+import { Box3, Matrix4, Vector3 } from 'three';
+/** Plan footprint in the item root's horizontal (x, z) plane — stored as floorplan polygon. */
+export function computePlanFootprintPolygonLocal(object) {
+    object.updateWorldMatrix(true, true);
+    const inverseRootMatrix = new Matrix4().copy(object.matrixWorld).invert();
+    const localMatrix = new Matrix4();
+    const scratchBounds = new Box3();
+    const scratchPosition = new Vector3();
+    const footprintPoints = [];
+    const collectPoints = (child) => {
+        const mesh = child;
+        if (mesh.isMesh && mesh.name !== 'cutout' && mesh.geometry) {
+            if (!mesh.geometry.boundingBox && mesh.geometry.computeBoundingBox) {
+                mesh.geometry.computeBoundingBox();
+            }
+            localMatrix.copy(inverseRootMatrix).multiply(mesh.matrixWorld);
+            const vertexPositions = mesh.geometry.attributes?.position;
+            if (vertexPositions && vertexPositions.count > 0) {
+                for (let index = 0; index < vertexPositions.count; index += 1) {
+                    scratchPosition
+                        .set(vertexPositions.getX(index), vertexPositions.getY(index), vertexPositions.getZ(index))
+                        .applyMatrix4(localMatrix);
+                    if (Number.isFinite(scratchPosition.x) && Number.isFinite(scratchPosition.z)) {
+                        footprintPoints.push({ x: scratchPosition.x, y: scratchPosition.z });
+                    }
+                }
+            }
+            else if (mesh.geometry.boundingBox) {
+                scratchBounds.copy(mesh.geometry.boundingBox);
+                scratchBounds.applyMatrix4(localMatrix);
+                if (Number.isFinite(scratchBounds.min.x) && Number.isFinite(scratchBounds.max.x)) {
+                    footprintPoints.push({ x: scratchBounds.min.x, y: scratchBounds.min.z }, { x: scratchBounds.max.x, y: scratchBounds.min.z }, { x: scratchBounds.max.x, y: scratchBounds.max.z }, { x: scratchBounds.min.x, y: scratchBounds.max.z });
+                }
+            }
+        }
+        for (const grandchild of child.children) {
+            collectPoints(grandchild);
+        }
+    };
+    for (const child of object.children) {
+        collectPoints(child);
+    }
+    return getMinimumAreaBoundingRect(footprintPoints) ?? [];
+}
+export function computeMeshLocalBoundsFromObject(object) {
+    object.updateWorldMatrix(true, true);
+    const inverseRootMatrix = new Matrix4().copy(object.matrixWorld).invert();
+    const localMatrix = new Matrix4();
+    const localBounds = new Box3();
+    const scratchBounds = new Box3();
+    let hasBounds = false;
+    const expandBounds = (child) => {
+        const mesh = child;
+        if (mesh.isMesh && mesh.name !== 'cutout' && mesh.geometry) {
+            if (!mesh.geometry.boundingBox && mesh.geometry.computeBoundingBox) {
+                mesh.geometry.computeBoundingBox();
+            }
+            if (mesh.geometry.boundingBox) {
+                localMatrix.copy(inverseRootMatrix).multiply(mesh.matrixWorld);
+                scratchBounds.copy(mesh.geometry.boundingBox).applyMatrix4(localMatrix);
+                if (!hasBounds) {
+                    localBounds.copy(scratchBounds);
+                    hasBounds = true;
+                }
+                else {
+                    localBounds.union(scratchBounds);
+                }
+            }
+        }
+        for (const grandchild of child.children) {
+            expandBounds(grandchild);
+        }
+    };
+    for (const child of object.children) {
+        expandBounds(child);
+    }
+    if (!hasBounds)
+        return null;
+    return {
+        min: [localBounds.min.x, localBounds.min.y, localBounds.min.z],
+        max: [localBounds.max.x, localBounds.max.y, localBounds.max.z],
+    };
+}
+function getMinimumAreaBoundingRect(points) {
+    if (points.length === 0)
+        return null;
+    if (points.length < 3)
+        return points;
+    const hull = getConvexHull(points);
+    if (hull.length < 3)
+        return hull;
+    let bestArea = Number.POSITIVE_INFINITY;
+    let bestRect = null;
+    for (let index = 0; index < hull.length; index += 1) {
+        const nextIndex = (index + 1) % hull.length;
+        const current = hull[index];
+        const next = hull[nextIndex];
+        const angle = Math.atan2(next.y - current.y, next.x - current.x);
+        const cos = Math.cos(-angle);
+        const sin = Math.sin(-angle);
+        let minX = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        for (const point of hull) {
+            const rx = point.x * cos - point.y * sin;
+            const ry = point.x * sin + point.y * cos;
+            minX = Math.min(minX, rx);
+            maxX = Math.max(maxX, rx);
+            minY = Math.min(minY, ry);
+            maxY = Math.max(maxY, ry);
+        }
+        const area = (maxX - minX) * (maxY - minY);
+        if (area >= bestArea)
+            continue;
+        bestArea = area;
+        const unrotate = (x, y) => ({
+            x: x * Math.cos(angle) - y * Math.sin(angle),
+            y: x * Math.sin(angle) + y * Math.cos(angle),
+        });
+        bestRect = [
+            unrotate(minX, minY),
+            unrotate(maxX, minY),
+            unrotate(maxX, maxY),
+            unrotate(minX, maxY),
+        ];
+    }
+    return bestRect;
+}
+function getConvexHull(points) {
+    if (points.length <= 1)
+        return points;
+    const sorted = [...points].sort((a, b) => (a.x === b.x ? a.y - b.y : a.x - b.x));
+    const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    const lower = [];
+    for (const point of sorted) {
+        while (lower.length >= 2 &&
+            cross(lower[lower.length - 2], lower[lower.length - 1], point) <= 0) {
+            lower.pop();
+        }
+        lower.push(point);
+    }
+    const upper = [];
+    for (let index = sorted.length - 1; index >= 0; index -= 1) {
+        const point = sorted[index];
+        while (upper.length >= 2 &&
+            cross(upper[upper.length - 2], upper[upper.length - 1], point) <= 0) {
+            upper.pop();
+        }
+        upper.push(point);
+    }
+    lower.pop();
+    upper.pop();
+    return [...lower, ...upper];
+}

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Writes `meshLocalPlanPolygon` / `meshLocalBounds` from loaded item meshes.
+ * ModelRenderer requests sync via `requestItemMeshMetadataSync` when GLTF is ready.
+ */
+export declare function ItemMeshMetadataSystem(): null;
+//# sourceMappingURL=item-mesh-metadata-system.d.ts.map

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-mesh-metadata-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-mesh-metadata/item-mesh-metadata-system.tsx"],"names":[],"mappings":"AAoFA;;;GAGG;AACH,wBAAgB,sBAAsB,SAYrC"}

package/dist/systems/item-mesh-metadata/item-mesh-metadata-system.js

@@ -0,0 +1,75 @@
+'use client';
+import { sceneRegistry, useScene } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { computeMeshLocalBoundsFromObject, computePlanFootprintPolygonLocal, } from './compute-item-mesh-metadata';
+import { drainItemMeshMetadataSyncRequests, getItemMeshMetadataSourceRoot } from './sync-request';
+function isMetadataUnchanged(nextPolygon, nextBounds, metadata) {
+    const currentPolygon = metadata.meshLocalPlanPolygon;
+    const currentBounds = typeof metadata.meshLocalBounds === 'object' &&
+        metadata.meshLocalBounds !== null &&
+        !Array.isArray(metadata.meshLocalBounds)
+        ? metadata.meshLocalBounds
+        : null;
+    const polygonUnchanged = (nextPolygon === null &&
+        (currentPolygon === undefined || currentPolygon === null || currentPolygon === false)) ||
+        (Array.isArray(currentPolygon) &&
+            nextPolygon !== null &&
+            currentPolygon.length === nextPolygon.length &&
+            currentPolygon.every((point, index) => Array.isArray(point) &&
+                point[0] === nextPolygon[index]?.[0] &&
+                point[1] === nextPolygon[index]?.[1]));
+    const boundsUnchanged = (nextBounds === null && (currentBounds === undefined || currentBounds === null)) ||
+        (nextBounds !== null &&
+            Array.isArray(currentBounds?.min) &&
+            Array.isArray(currentBounds?.max) &&
+            currentBounds.min[0] === nextBounds.min[0] &&
+            currentBounds.min[1] === nextBounds.min[1] &&
+            currentBounds.min[2] === nextBounds.min[2] &&
+            currentBounds.max[0] === nextBounds.max[0] &&
+            currentBounds.max[1] === nextBounds.max[1] &&
+            currentBounds.max[2] === nextBounds.max[2]);
+    return polygonUnchanged && boundsUnchanged;
+}
+function trySyncItemMeshMetadata(itemId, nodes) {
+    const node = nodes[itemId];
+    if (!node || node.type !== 'item')
+        return;
+    const root = getItemMeshMetadataSourceRoot(itemId) ??
+        sceneRegistry.nodes.get(itemId);
+    if (!root)
+        return;
+    const polygon = computePlanFootprintPolygonLocal(root);
+    const bounds = computeMeshLocalBoundsFromObject(root);
+    if (polygon.length < 3 && !bounds)
+        return;
+    const nextPolygon = polygon.length >= 3 ? polygon.map(({ x, y }) => [x, y]) : null;
+    const nextBounds = bounds ? { min: bounds.min, max: bounds.max } : null;
+    const metadata = typeof node.metadata === 'object' && node.metadata !== null && !Array.isArray(node.metadata)
+        ? node.metadata
+        : {};
+    if (isMetadataUnchanged(nextPolygon, nextBounds, metadata))
+        return;
+    useScene.getState().updateNode(itemId, {
+        metadata: {
+            ...metadata,
+            ...(nextPolygon ? { meshLocalPlanPolygon: nextPolygon } : {}),
+            ...(nextBounds ? { meshLocalBounds: nextBounds } : {}),
+        },
+    });
+}
+/**
+ * Writes `meshLocalPlanPolygon` / `meshLocalBounds` from loaded item meshes.
+ * ModelRenderer requests sync via `requestItemMeshMetadataSync` when GLTF is ready.
+ */
+export function ItemMeshMetadataSystem() {
+    useFrame(() => {
+        const ids = drainItemMeshMetadataSyncRequests();
+        if (ids.length === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        for (const id of ids) {
+            trySyncItemMeshMetadata(id, nodes);
+        }
+    });
+    return null;
+}

package/dist/systems/item-mesh-metadata/sync-request.d.ts

@@ -0,0 +1,7 @@
+import type { Object3D } from 'three';
+/** Called when an item's loaded GLTF (or metadata driving footprint) may need re-syncing. */
+export declare function requestItemMeshMetadataSync(itemId: string): void;
+export declare function setItemMeshMetadataSourceRoot(itemId: string, root: Object3D | null): void;
+export declare function getItemMeshMetadataSourceRoot(itemId: string): Object3D | undefined;
+export declare function drainItemMeshMetadataSyncRequests(): string[];
+//# sourceMappingURL=sync-request.d.ts.map

package/dist/systems/item-mesh-metadata/sync-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-request.d.ts","sourceRoot":"","sources":["../../../src/systems/item-mesh-metadata/sync-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAMrC,6FAA6F;AAC7F,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,QAEzD;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,QAMlF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAElF;AAED,wBAAgB,iCAAiC,IAAI,MAAM,EAAE,CAK5D"}

package/dist/systems/item-mesh-metadata/sync-request.js

@@ -0,0 +1,25 @@
+const pendingIds = new Set();
+/** Preferred root for footprint math (Clone root). Falls back to sceneRegistry item root. */
+const sourceRoots = new Map();
+/** Called when an item's loaded GLTF (or metadata driving footprint) may need re-syncing. */
+export function requestItemMeshMetadataSync(itemId) {
+    pendingIds.add(itemId);
+}
+export function setItemMeshMetadataSourceRoot(itemId, root) {
+    if (root) {
+        sourceRoots.set(itemId, root);
+    }
+    else {
+        sourceRoots.delete(itemId);
+    }
+}
+export function getItemMeshMetadataSourceRoot(itemId) {
+    return sourceRoots.get(itemId);
+}
+export function drainItemMeshMetadataSyncRequests() {
+    if (pendingIds.size === 0)
+        return [];
+    const ids = [...pendingIds];
+    pendingIds.clear();
+    return ids;
+}

package/dist/systems/roof/roof-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAiBhG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,iBAAiB,GAAG,IAAI,CAmB7E"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA4BhG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,iBAAiB,GAAG,IAAI,CA8B7E"}

package/dist/systems/roof/roof-materials.js

@@ -1,6 +1,13 @@
 import { getEffectiveRoofSurfaceMaterial, } from '@pascal-app/core';
 import * as THREE from 'three';
 import { createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
+const roofMaterialArrayCache = new Map();
+function getSurfaceMaterialSignature(spec) {
+    return JSON.stringify({
+        material: spec.material ?? null,
+        materialPreset: spec.materialPreset ?? null,
+    });
+}
 function createResolvedMaterial(material, materialPreset) {
     if (materialPreset) {
         return createMaterialFromPresetRef(materialPreset);
@@ -14,16 +21,26 @@ export function getRoofMaterialArray(node) {
     const top = getEffectiveRoofSurfaceMaterial(node, 'top');
     const edge = getEffectiveRoofSurfaceMaterial(node, 'edge');
     const wall = getEffectiveRoofSurfaceMaterial(node, 'wall');
+    const cacheKey = JSON.stringify({
+        top: getSurfaceMaterialSignature(top),
+        edge: getSurfaceMaterialSignature(edge),
+        wall: getSurfaceMaterialSignature(wall),
+    });
+    const cached = roofMaterialArrayCache.get(cacheKey);
+    if (cached)
+        return cached;
     const topMaterial = createResolvedMaterial(top.material, top.materialPreset);
     const edgeMaterial = createResolvedMaterial(edge.material, edge.materialPreset);
     const wallMaterial = createResolvedMaterial(wall.material, wall.materialPreset);
     if (!(topMaterial || edgeMaterial || wallMaterial)) {
         return null;
     }
-    return [
+    const materialArray = [
         edgeMaterial ?? wallMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         wallMaterial ?? edgeMaterial ?? topMaterial ?? new THREE.MeshStandardMaterial(),
         topMaterial ?? wallMaterial ?? edgeMaterial ?? new THREE.MeshStandardMaterial(),
     ];
+    roofMaterialArrayCache.set(cacheKey, materialArray);
+    return materialArray;
 }

package/dist/systems/roof/roof-system.d.ts

@@ -0,0 +1,16 @@
+import { type RoofSegmentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { Brush } from 'three-bvh-csg';
+export declare const RoofSystem: () => null;
+/**
+ * Generate complete hollow-shell geometry for a roof segment.
+ * Ports the prototype's CSG approach using three-bvh-csg.
+ */
+export declare function getRoofSegmentBrushes(node: RoofSegmentNode): {
+    deckSlab: Brush;
+    shinSlab: Brush;
+    wallBrush: Brush;
+    innerBrush: Brush;
+} | null;
+export declare function generateRoofSegmentGeometry(node: RoofSegmentNode): THREE.BufferGeometry;
+//# sourceMappingURL=roof-system.d.ts.map

package/dist/systems/roof/roof-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-system.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAmCvE,eAAO,MAAM,UAAU,YAsFtB,CAAA;AAuLD;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,eAAe,GACpB;IAAE,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CAqRlF;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,cAAc,CAqDvF"}