@pascal-app/viewer 0.9.1 → 1.0.0-beta.1

package/dist/store/use-viewer.js

@@ -1,10 +1,137 @@
 'use client';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
+import { SCENE_THEME_IDS } from '../lib/scene-themes';
+const CAMERA_MODES = ['perspective', 'orthographic'];
+const RENDER_SHADINGS = ['solid', 'rendered'];
+const COLOR_PRESETS = ['clay', 'white', 'mono', 'blueprint'];
+const EDGE_MODES = ['off', 'soft', 'strong'];
+const UNITS = ['metric', 'imperial'];
+const METRIC_NOTATIONS = ['meters', 'millimeters'];
+const LEVEL_MODES = ['stacked', 'exploded', 'solo', 'manual'];
+const WALL_MODES = ['up', 'cutaway', 'down', 'translucent'];
+// Countries still on imperial/US customary units: United States, Liberia, Myanmar.
+const IMPERIAL_REGIONS = ['US', 'LR', 'MM'];
+// IANA zones for those countries. The timezone tracks the OS clock (actual
+// location), unlike navigator.language where en-US is a common default for
+// users far outside the US.
+const IMPERIAL_TIMEZONES = new Set([
+    'America/New_York',
+    'America/Detroit',
+    'America/Kentucky/Louisville',
+    'America/Kentucky/Monticello',
+    'America/Indiana/Indianapolis',
+    'America/Indiana/Vincennes',
+    'America/Indiana/Winamac',
+    'America/Indiana/Marengo',
+    'America/Indiana/Petersburg',
+    'America/Indiana/Vevay',
+    'America/Indiana/Tell_City',
+    'America/Indiana/Knox',
+    'America/Chicago',
+    'America/Menominee',
+    'America/North_Dakota/Center',
+    'America/North_Dakota/New_Salem',
+    'America/North_Dakota/Beulah',
+    'America/Denver',
+    'America/Boise',
+    'America/Phoenix',
+    'America/Los_Angeles',
+    'America/Anchorage',
+    'America/Juneau',
+    'America/Sitka',
+    'America/Metlakatla',
+    'America/Yakutat',
+    'America/Nome',
+    'America/Adak',
+    'Pacific/Honolulu',
+    'America/Puerto_Rico',
+    'Pacific/Guam',
+    'Africa/Monrovia', // Liberia
+    'Asia/Yangon', // Myanmar
+    'Asia/Rangoon', // Myanmar (legacy alias)
+]);
+function detectDefaultUnit() {
+    if (typeof navigator === 'undefined')
+        return 'metric';
+    try {
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (timeZone)
+            return IMPERIAL_TIMEZONES.has(timeZone) ? 'imperial' : 'metric';
+        // No timezone available: fall back to an explicit locale region subtag
+        // only (never maximize() — it turns a bare "en" into region US).
+        const region = new Intl.Locale(navigator.language).region;
+        return region && IMPERIAL_REGIONS.includes(region) ? 'imperial' : 'metric';
+    }
+    catch {
+        return 'metric';
+    }
+}
+function pickString(value, allowed, fallback) {
+    return typeof value === 'string' && allowed.includes(value) ? value : fallback;
+}
+function normalizeShadingByContext(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const next = {};
+    for (const [context, shading] of Object.entries(value)) {
+        if (context !== 'editor' && context !== 'viewer')
+            continue;
+        next[context] = pickString(shading, RENDER_SHADINGS, 'rendered');
+    }
+    return next;
+}
+function normalizeProjectPreferences(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const next = {};
+    for (const [projectId, preferences] of Object.entries(value)) {
+        if (!preferences || typeof preferences !== 'object' || Array.isArray(preferences))
+            continue;
+        const record = preferences;
+        next[projectId] = {
+            ...(typeof record.showScans === 'boolean' ? { showScans: record.showScans } : {}),
+            ...(typeof record.showGuides === 'boolean' ? { showGuides: record.showGuides } : {}),
+            ...(typeof record.showGrid === 'boolean' ? { showGrid: record.showGrid } : {}),
+            ...(typeof record.showMeasurements === 'boolean'
+                ? { showMeasurements: record.showMeasurements }
+                : {}),
+        };
+    }
+    return next;
+}
+function normalizePersistedViewerState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const state = value;
+    return {
+        cameraMode: pickString(state.cameraMode, CAMERA_MODES, 'perspective'),
+        sceneTheme: pickString(state.sceneTheme, SCENE_THEME_IDS, 'studio'),
+        shadingByContext: normalizeShadingByContext(state.shadingByContext),
+        textures: typeof state.textures === 'boolean' ? state.textures : true,
+        colorPreset: pickString(state.colorPreset, COLOR_PRESETS, 'clay'),
+        edges: pickString(state.edges, EDGE_MODES, 'soft'),
+        shadows: typeof state.shadows === 'boolean' ? state.shadows : true,
+        unit: pickString(state.unit, UNITS, detectDefaultUnit()),
+        metricNotation: pickString(state.metricNotation, METRIC_NOTATIONS, 'meters'),
+        unitExplicit: typeof state.unit === 'string' && UNITS.includes(state.unit),
+        levelMode: pickString(state.levelMode, LEVEL_MODES, 'stacked'),
+        wallMode: pickString(state.wallMode, WALL_MODES, 'up'),
+        projectPreferences: normalizeProjectPreferences(state.projectPreferences),
+    };
+}
 const useViewer = create()(persist((set) => ({
     selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
     previewSelectedIds: [],
     setPreviewSelectedIds: (ids) => set({ previewSelectedIds: ids }),
+    externalSelectedIds: [],
+    setExternalSelectedIds: (ids) => set((state) => {
+        if (state.externalSelectedIds.length === ids.length &&
+            state.externalSelectedIds.every((id, index) => id === ids[index])) {
+            return state;
+        }
+        return { externalSelectedIds: ids };
+    }),
     hoverHighlightMode: 'default',
     setHoverHighlightMode: (mode) => set((state) => (state.hoverHighlightMode === mode ? state : { hoverHighlightMode: mode })),
     hoveredId: null,
@@ -15,6 +142,21 @@ const useViewer = create()(persist((set) => ({
     setSceneTheme: (id) => set({ sceneTheme: id }),
     renderContext: 'editor',
     setRenderContext: (context) => set({ renderContext: context }),
+    isExporting: false,
+    setExporting: (value) => set({ isExporting: value }),
+    itemLoadFailures: {},
+    reportItemLoadFailure: (nodeId, url) => set((state) => state.itemLoadFailures[nodeId] === url
+        ? state
+        : { itemLoadFailures: { ...state.itemLoadFailures, [nodeId]: url } }),
+    clearItemLoadFailure: (nodeId) => set((state) => {
+        if (!(nodeId in state.itemLoadFailures))
+            return state;
+        const next = { ...state.itemLoadFailures };
+        delete next[nodeId];
+        return { itemLoadFailures: next };
+    }),
+    renderPaused: false,
+    setRenderPaused: (value) => set({ renderPaused: value }),
     shading: 'rendered',
     shadingByContext: {},
     setShading: (shading) => set((state) => ({
@@ -29,8 +171,11 @@ const useViewer = create()(persist((set) => ({
     setEdges: (edges) => set({ edges }),
     shadows: true,
     setShadows: (shadows) => set({ shadows }),
-    unit: 'metric',
-    setUnit: (unit) => set({ unit }),
+    unit: detectDefaultUnit(),
+    metricNotation: 'meters',
+    unitExplicit: false,
+    setUnit: (unit) => set({ unit, unitExplicit: true }),
+    setMetricNotation: (metricNotation) => set({ unit: 'metric', metricNotation, unitExplicit: true }),
     levelMode: 'stacked',
     setLevelMode: (mode) => set({ levelMode: mode }),
     wallMode: 'up',
@@ -68,6 +213,23 @@ const useViewer = create()(persist((set) => ({
         }
         return { showGrid: show, projectPreferences };
     }),
+    showMeasurements: true,
+    setShowMeasurements: (show) => set((state) => {
+        const projectPreferences = { ...(state.projectPreferences || {}) };
+        if (state.projectId) {
+            projectPreferences[state.projectId] = {
+                ...(projectPreferences[state.projectId] || {}),
+                showMeasurements: show,
+            };
+        }
+        return { showMeasurements: show, projectPreferences };
+    }),
+    showZones: true,
+    setShowZones: (show) => set({ showZones: show }),
+    transparentBackground: false,
+    setTransparentBackground: (transparent) => set({ transparentBackground: transparent }),
+    inkOpacity: null,
+    setInkOpacity: (opacity) => set({ inkOpacity: opacity }),
     projectId: null,
     setProjectId: (id) => set((state) => {
         if (!id)
@@ -78,6 +240,7 @@ const useViewer = create()(persist((set) => ({
             showScans: prefs.showScans ?? true,
             showGuides: prefs.showGuides ?? true,
             showGrid: prefs.showGrid ?? true,
+            showMeasurements: prefs.showMeasurements ?? true,
         };
     }),
     projectPreferences: {},
@@ -114,18 +277,26 @@ const useViewer = create()(persist((set) => ({
         previewSelectedIds: [],
     }),
     outliner: { selectedObjects: [], hoveredObjects: [] },
+    geometryRevision: 0,
+    bumpGeometryRevision: () => set((state) => ({ geometryRevision: state.geometryRevision + 1 })),
     exportScene: null,
     setExportScene: (fn) => set({ exportScene: fn }),
     debugColors: false,
     setDebugColors: (enabled) => set({ debugColors: enabled }),
     walkthroughMode: false,
-    setWalkthroughMode: (mode) => set({ walkthroughMode: mode }),
+    setWalkthroughMode: (mode) => set({ walkthroughMode: mode, walkthroughSuspended: false }),
+    walkthroughSuspended: false,
+    setWalkthroughSuspended: (suspended) => set({ walkthroughSuspended: suspended }),
     cameraDragging: false,
     setCameraDragging: (dragging) => set({ cameraDragging: dragging }),
     inputDragging: false,
     setInputDragging: (dragging) => set({ inputDragging: dragging }),
 }), {
     name: 'viewer-preferences',
+    merge: (persistedState, currentState) => ({
+        ...currentState,
+        ...normalizePersistedViewerState(persistedState),
+    }),
     partialize: (state) => ({
         cameraMode: state.cameraMode,
         sceneTheme: state.sceneTheme,
@@ -134,10 +305,26 @@ const useViewer = create()(persist((set) => ({
         colorPreset: state.colorPreset,
         edges: state.edges,
         shadows: state.shadows,
-        unit: state.unit,
+        ...(state.unitExplicit ? { unit: state.unit } : {}),
+        metricNotation: state.metricNotation,
         levelMode: state.levelMode,
         wallMode: state.wallMode,
         projectPreferences: state.projectPreferences,
     }),
 }));
+/** Apply an authoritative country code (e.g. IP-derived by the host app) as
+ * the unit default. Stronger signal than the timezone heuristic used at store
+ * creation, but still a default: it never overrides an explicit user choice
+ * and is not persisted (the unit only sticks once the user touches the
+ * toggle). */
+export function applyCountryUnitDefault(country) {
+    if (!country)
+        return;
+    const state = useViewer.getState();
+    if (state.unitExplicit)
+        return;
+    const unit = IMPERIAL_REGIONS.includes(country.toUpperCase()) ? 'imperial' : 'metric';
+    if (state.unit !== unit)
+        useViewer.setState({ unit });
+}
 export default useViewer;

package/dist/store/use-viewer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-viewer.test.d.ts.map

package/dist/store/use-viewer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-viewer.test.d.ts","sourceRoot":"","sources":["../../src/store/use-viewer.test.ts"],"names":[],"mappings":""}

package/dist/store/use-viewer.test.js

@@ -0,0 +1,61 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// include Bun ambient types in its production declaration build.
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import useViewer from './use-viewer';
+const resetMeasurementPreferences = () => {
+    useViewer.setState({
+        externalSelectedIds: [],
+        projectId: null,
+        projectPreferences: {},
+        showMeasurements: true,
+        unit: 'metric',
+        metricNotation: 'meters',
+    });
+};
+beforeEach(resetMeasurementPreferences);
+afterEach(resetMeasurementPreferences);
+describe('measurement display preferences', () => {
+    test('stores global visibility per project and defaults new projects to visible', () => {
+        const viewer = useViewer.getState();
+        viewer.setProjectId('project-a');
+        viewer.setShowMeasurements(false);
+        expect(useViewer.getState()).toMatchObject({
+            projectId: 'project-a',
+            showMeasurements: false,
+            projectPreferences: {
+                'project-a': { showMeasurements: false },
+            },
+        });
+        useViewer.getState().setProjectId('project-b');
+        expect(useViewer.getState().showMeasurements).toBe(true);
+        useViewer.getState().setProjectId('project-a');
+        expect(useViewer.getState().showMeasurements).toBe(false);
+    });
+    test('changes display units without changing measurement visibility preferences', () => {
+        const viewer = useViewer.getState();
+        viewer.setProjectId('project-a');
+        viewer.setShowMeasurements(false);
+        const preferences = useViewer.getState().projectPreferences;
+        useViewer.getState().setUnit('imperial');
+        expect(useViewer.getState().unit).toBe('imperial');
+        expect(useViewer.getState().projectPreferences).toEqual(preferences);
+        expect(useViewer.getState().showMeasurements).toBe(false);
+    });
+    test('selects millimeters as a metric display notation', () => {
+        useViewer.getState().setUnit('imperial');
+        useViewer.getState().setMetricNotation('millimeters');
+        expect(useViewer.getState()).toMatchObject({
+            unit: 'metric',
+            metricNotation: 'millimeters',
+            unitExplicit: true,
+        });
+    });
+});
+describe('external selection highlights', () => {
+    test('tracks host-owned highlights without changing the local selection', () => {
+        const localSelection = useViewer.getState().selection;
+        useViewer.getState().setExternalSelectedIds(['wall_remote']);
+        expect(useViewer.getState().externalSelectedIds).toEqual(['wall_remote']);
+        expect(useViewer.getState().selection).toBe(localSelection);
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAMjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAgB9B,eAAO,MAAM,aAAa,YA4BzB,CAAA;AA2DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAM,GAC9C,KAAK,CAAC,cAAc,CA0DtB"}
+{"version":3,"file":"ceiling-system.d.ts","sourceRoot":"","sources":["../../../src/systems/ceiling/ceiling-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAgB9B,eAAO,MAAM,aAAa,YA4BzB,CAAA;AAgED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAM,GAC9C,KAAK,CAAC,cAAc,CA6DtB"}

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

@@ -1,4 +1,4 @@
-import { getEffectiveNode, nodeRegistry, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, nodeRegistry, resolveCeilingHeight, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
@@ -21,7 +21,7 @@ export const CeilingSystem = () => {
         // Process dirty ceilings
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
-            if (!node || node.type !== 'ceiling')
+            if (node?.type !== 'ceiling')
                 return;
             const mesh = sceneRegistry.nodes.get(id);
             if (mesh) {
@@ -30,7 +30,7 @@ export const CeilingSystem = () => {
                 // the final value on commit. Mirrors WallSystem / GeometrySystem.
                 const effective = getEffectiveNode(node);
                 const itemHoles = collectCeilingHoles(effective, nodes);
-                updateCeilingGeometry(effective, mesh, itemHoles);
+                updateCeilingGeometry(effective, mesh, itemHoles, nodes);
                 clearDirty(id);
             }
             // If mesh not found, keep it dirty for next frame
@@ -64,7 +64,7 @@ function collectCeilingHoles(ceiling, nodes) {
 /**
  * Updates the geometry for a single ceiling
  */
-function updateCeilingGeometry(node, mesh, extraHoles = []) {
+function updateCeilingGeometry(node, mesh, extraHoles = [], nodes = useScene.getState().nodes) {
     const newGeo = generateCeilingGeometry(node, extraHoles);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;
@@ -81,7 +81,11 @@ function updateCeilingGeometry(node, mesh, extraHoles = []) {
     const liveTransform = useLiveTransforms.getState().get(node.id);
     mesh.position.x = liveTransform?.position[0] ?? 0;
     mesh.position.z = liveTransform?.position[2] ?? 0;
-    mesh.position.y = (node.height ?? 2.5) - 0.01 + (liveTransform?.position[1] ?? 0); // Slight offset to avoid z-fighting with upper-level slabs
+    // Resolved height: explicit when stored, else the level-top bound — so a
+    // follows-mode ceiling re-parks under the current plane on every rebuild
+    // (level-height edits / covering-slab changes dirty-mark ceilings).
+    // Slight offset to avoid z-fighting with upper-level slabs.
+    mesh.position.y = resolveCeilingHeight(node, nodes) - 0.01 + (liveTransform?.position[1] ?? 0);
 }
 /**
  * Generates flat ceiling geometry from polygon (no extrusion).
@@ -101,6 +105,9 @@ export function generateCeilingGeometry(ceilingNode, extraHoles = []) {
         // the whole command encoder.
         const degenerate = new THREE.BufferGeometry();
         degenerate.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        degenerate.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        degenerate.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+        degenerate.setAttribute('uv2', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
         return degenerate;
     }
     // Create shape from polygon

package/dist/systems/door/door-animation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=door-animation.test.d.ts.map

package/dist/systems/door/door-animation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-animation.test.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-animation.test.ts"],"names":[],"mappings":""}

package/dist/systems/door/door-animation.test.js

@@ -0,0 +1,51 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { buildDoorPreviewMesh, poseDoorMovingParts } from '../../index';
+// The named moving group each operation-door builder emits at the closed pose.
+const MOVING_GROUP = {
+    sliding: 'door-sliding-active',
+    pocket: 'door-pocket-leaf',
+    barn: 'door-barn-leaf',
+    'garage-tiltup': 'door-tiltup-leaf',
+    folding: 'door-fold-0',
+    'garage-sectional': 'door-sectional-0',
+    'garage-rollup': 'door-rollup-curtain',
+};
+function worldPosition(object) {
+    object.updateMatrixWorld(true);
+    return object.getWorldPosition(new THREE.Vector3());
+}
+describe('operation door open kinematics', () => {
+    // Each operation door builds its moving parts in a named group at the closed
+    // pose; `poseDoorMovingParts` then drives the open motion (the single source
+    // of truth shared by the live system and the GLB exporter). This guards the
+    // build-once + pose-at-t contract: the group exists, rests closed, and moves.
+    for (const doorType of Object.keys(MOVING_GROUP)) {
+        test(`${doorType} builds a moving group that opens`, () => {
+            const node = DoorNode.parse({ id: `door_${doorType}`, doorType, operationState: 0 });
+            const mesh = buildDoorPreviewMesh(node);
+            const group = mesh.getObjectByName(MOVING_GROUP[doorType]);
+            expect(group).toBeDefined();
+            // Closed snapshot.
+            poseDoorMovingParts(node, mesh, 0);
+            const closedPos = worldPosition(group);
+            const closedScaleY = group.scale.y;
+            const closedRotX = group.rotation.x;
+            const closedRotY = group.rotation.y;
+            // Open snapshot — at least one of translation / rotation / scale changes.
+            poseDoorMovingParts(node, mesh, 1);
+            const openPos = worldPosition(group);
+            const moved = closedPos.distanceTo(openPos) > 0.05 ||
+                Math.abs(closedScaleY - group.scale.y) > 0.1 ||
+                Math.abs(closedRotX - group.rotation.x) > 0.05 ||
+                Math.abs(closedRotY - group.rotation.y) > 0.05;
+            expect(moved).toBe(true);
+            // Posing back to closed is the identity of the rest pose.
+            poseDoorMovingParts(node, mesh, 0);
+            expect(worldPosition(group).distanceTo(closedPos)).toBeLessThan(1e-6);
+        });
+    }
+});

package/dist/systems/door/door-floor-alignment.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=door-floor-alignment.test.d.ts.map

package/dist/systems/door/door-floor-alignment.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-floor-alignment.test.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-floor-alignment.test.ts"],"names":[],"mappings":""}

package/dist/systems/door/door-floor-alignment.test.js

@@ -0,0 +1,50 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { buildDoorPreviewMesh } from '../../index';
+const DOOR_TYPES = [
+    'hinged',
+    'double',
+    'french',
+    'folding',
+    'pocket',
+    'barn',
+    'sliding',
+    'garage-sectional',
+    'garage-rollup',
+    'garage-tiltup',
+];
+function visibleBounds(mesh) {
+    mesh.updateMatrixWorld(true);
+    const bounds = new THREE.Box3();
+    for (const child of mesh.children) {
+        if (child.name === 'cutout')
+            continue;
+        bounds.expandByObject(child, true);
+    }
+    return bounds;
+}
+describe('door floor alignment', () => {
+    for (const doorType of DOOR_TYPES) {
+        test(`${doorType} does not extend below the opening floor`, () => {
+            const node = DoorNode.parse({
+                id: `door_floor-alignment-${doorType}`,
+                doorType,
+                operationState: 0,
+                threshold: true,
+            });
+            const mesh = buildDoorPreviewMesh(node);
+            const bounds = visibleBounds(mesh);
+            expect(bounds.min.y).toBeGreaterThanOrEqual(-node.height / 2 - 1e-6);
+        });
+    }
+    test('keeps the wall cutout bottom locked to the opening floor', () => {
+        const node = DoorNode.parse({ id: 'door_floor-alignment-cutout' });
+        const mesh = buildDoorPreviewMesh(node);
+        const cutout = mesh.getObjectByName('cutout');
+        cutout.geometry.computeBoundingBox();
+        expect(cutout.geometry.boundingBox?.min.y).toBeCloseTo(-node.height / 2, 6);
+    });
+});

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

@@ -1,2 +1,26 @@
+import { type DoorNode } from '@pascal-app/core';
+import * as THREE from 'three';
 export declare const DoorSystem: () => null;
+/**
+ * Pose an operation door's moving parts (sliding/pocket/barn leaf, tilt-up and
+ * sectional panels, folding chain, roll-up curtain) at `value` (0 = closed,
+ * 1 = open) by transforming the named groups its builder emitted at the closed
+ * pose. Returns true when the door type has a pose path and its groups exist.
+ *
+ * Mirrors `poseWindowMovingParts`: the live door system calls it after a
+ * (re)build so `operationState` is reflected, and the GLB exporter calls it on a
+ * clone to sample keyframes. Swing doors are not handled here — their leaf group
+ * carries a `pascalSwingLeaf` marker the exporter reads directly.
+ *
+ * Roll-up is the one type whose live geometry changes (slats vanish onto a
+ * drum), which a glTF clip can't express; the baked approximation scales the
+ * curtain up into the lintel. The live roll-up animation keeps its full-detail
+ * rebuild and is intentionally NOT routed through this scale.
+ */
+export declare function poseDoorMovingParts(node: DoorNode, mesh: THREE.Object3D | undefined, value: number): boolean;
+/**
+ * Build a fresh door mesh for preview/ghost rendering.
+ * Returns a mesh with an invisible hitbox root and visible children (frame, panels, hardware).
+ */
+export declare function buildDoorPreviewMesh(node: DoorNode): THREE.Mesh;
 //# sourceMappingURL=door-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AA8CA,eAAO,MAAM,UAAU,YAwFtB,CAAA"}
+{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA0D9B,eAAO,MAAM,UAAU,YA6GtB,CAAA;AAupCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,SAAS,EAChC,KAAK,EAAE,MAAM,GACZ,OAAO,CA6GT;AAyuCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC,IAAI,CAI/D"}