@pascal-app/viewer 1.0.5 → 1.0.7

package/dist/systems/wall/wall-t-junctions.js

@@ -0,0 +1,149 @@
+import * as THREE from 'three';
+const T_JUNCTION_EPSILON = 1e-5;
+// CSG T-junction vertices sit within Float32 rounding (≲3e-7 m) of the edge
+// they split; finely tessellated arch vertices can sit ~1e-5 m off a chord
+// and must not be pulled onto it.
+const ON_EDGE_EPSILON = 1e-6;
+const WELD_GRID = 1e-6;
+/**
+ * Splits every triangle whose edge carries another triangle's vertex, so the
+ * neighbours share that vertex instead of meeting at a T-junction. CSG cuts and
+ * finish-band splits leave T-junctions on wall faces: they look closed at full
+ * float precision, but crack open into dotted light leaks once a GLB bake
+ * quantizes positions.
+ *
+ * Each piece keeps its source triangle's material group, so the repair never
+ * reclassifies a face. Geometry without T-junctions is returned untouched;
+ * otherwise the result is non-indexed and position-only (callers recompute
+ * normals) and the input is disposed.
+ */
+export function repairWallTJunctions(geometry) {
+    const position = geometry.getAttribute('position');
+    const index = geometry.getIndex();
+    const cornerCount = index ? index.count : (position?.count ?? 0);
+    if (!position || cornerCount < 3)
+        return geometry;
+    // Welded vertex table: every corner snaps to one representative so that
+    // edges sharing a vertex share its exact coordinates.
+    const welded = new Map();
+    const points = [];
+    const corners = new Uint32Array(cornerCount);
+    for (let corner = 0; corner < cornerCount; corner += 1) {
+        const vertex = index ? index.getX(corner) : corner;
+        const x = position.getX(vertex);
+        const y = position.getY(vertex);
+        const z = position.getZ(vertex);
+        const key = `${Math.round(x / WELD_GRID)},${Math.round(y / WELD_GRID)},${Math.round(z / WELD_GRID)}`;
+        let id = welded.get(key);
+        if (id === undefined) {
+            id = points.length;
+            points.push([x, y, z]);
+            welded.set(key, id);
+        }
+        corners[corner] = id;
+    }
+    const byX = points.map((_, id) => id).sort((a, b) => points[a][0] - points[b][0]);
+    const xs = byX.map((id) => points[id][0]);
+    const pointsOnEdge = (from, to) => {
+        const p = points[from];
+        const q = points[to];
+        const dx = q[0] - p[0];
+        const dy = q[1] - p[1];
+        const dz = q[2] - p[2];
+        const lengthSq = dx * dx + dy * dy + dz * dz;
+        if (lengthSq < T_JUNCTION_EPSILON * T_JUNCTION_EPSILON)
+            return [];
+        const minT = T_JUNCTION_EPSILON / Math.sqrt(lengthSq);
+        const maxX = Math.max(p[0], q[0]) + T_JUNCTION_EPSILON;
+        const hits = [];
+        for (let k = lowerBound(xs, Math.min(p[0], q[0]) - T_JUNCTION_EPSILON); k < xs.length; k += 1) {
+            if (xs[k] > maxX)
+                break;
+            const id = byX[k];
+            if (id === from || id === to)
+                continue;
+            const v = points[id];
+            const t = ((v[0] - p[0]) * dx + (v[1] - p[1]) * dy + (v[2] - p[2]) * dz) / lengthSq;
+            if (t <= minT || t >= 1 - minT)
+                continue;
+            const ox = p[0] + dx * t - v[0];
+            const oy = p[1] + dy * t - v[1];
+            const oz = p[2] + dz * t - v[2];
+            if (ox * ox + oy * oy + oz * oz > ON_EDGE_EPSILON * ON_EDGE_EPSILON)
+                continue;
+            hits.push({ id, t });
+        }
+        return hits.sort((a, b) => a.t - b.t).map((hit) => hit.id);
+    };
+    const edgePoints = [];
+    let found = false;
+    for (let corner = 0; corner + 2 < cornerCount; corner += 3) {
+        const a = corners[corner];
+        const b = corners[corner + 1];
+        const c = corners[corner + 2];
+        const ab = pointsOnEdge(a, b);
+        const bc = pointsOnEdge(b, c);
+        const ca = pointsOnEdge(c, a);
+        const split = ab.length > 0 || bc.length > 0 || ca.length > 0;
+        edgePoints.push(split ? [ab, bc, ca] : null);
+        found ||= split;
+    }
+    if (!found)
+        return geometry;
+    const out = [];
+    const push = (id) => {
+        const point = points[id];
+        out.push(point[0], point[1], point[2]);
+    };
+    // Splits at an edge point by joining it to the opposite corner. The new edge
+    // is interior, so it carries no points, and no vertex is ever invented.
+    const emit = (a, b, c, ab, bc, ca) => {
+        if (ab.length === 0 && bc.length === 0 && ca.length === 0) {
+            push(a);
+            push(b);
+            push(c);
+        }
+        else if (ab.length === 0) {
+            if (bc.length > 0)
+                emit(b, c, a, bc, ca, ab);
+            else
+                emit(c, a, b, ca, ab, bc);
+        }
+        else {
+            const mid = ab.length >> 1;
+            const p = ab[mid];
+            emit(a, p, c, ab.slice(0, mid), [], ca);
+            emit(p, b, c, ab.slice(mid + 1), bc, []);
+        }
+    };
+    const repaired = new THREE.BufferGeometry();
+    const groups = geometry.groups.length
+        ? geometry.groups
+        : [{ start: 0, count: cornerCount, materialIndex: undefined }];
+    for (const group of groups) {
+        const start = out.length / 3;
+        const end = Math.min(group.start + group.count, cornerCount);
+        for (let corner = group.start; corner + 2 < end; corner += 3) {
+            const [ab, bc, ca] = edgePoints[corner / 3] ?? [[], [], []];
+            emit(corners[corner], corners[corner + 1], corners[corner + 2], ab, bc, ca);
+        }
+        if (geometry.groups.length) {
+            repaired.addGroup(start, out.length / 3 - start, group.materialIndex);
+        }
+    }
+    repaired.setAttribute('position', new THREE.Float32BufferAttribute(out, 3));
+    geometry.dispose();
+    return repaired;
+}
+function lowerBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const mid = (low + high) >> 1;
+        if (values[mid] < target)
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    return low;
+}

package/dist/systems/window/window-animation-system.d.ts

@@ -1,14 +1,5 @@
-import { type WindowNode } from '@pascal-app/core';
-import type { Object3D } from 'three';
-/**
- * Pose a window's moving parts (sash/panel/slats) at `value` (0 = closed,
- * 1 = open) by mutating the named child groups under `mesh`. Returns true when
- * the window type has a direct pose path and the named parts were found.
- *
- * This is the single source of truth for window kinematics: the live animation
- * system poses the registered scene mesh, and the GLB exporter poses an export
- * clone to sample the open/close keyframes for a baked animation clip.
- */
-export declare function poseWindowMovingParts(node: WindowNode, mesh: Object3D | undefined, value: number): boolean;
+export { poseWindowMovingParts } from './window-pose';
+/** Advance the same viewer frame loop with an explicit clock for deterministic hosts and tests. */
+export declare function advanceWindowAnimations(now: number): void;
 export declare const WindowAnimationSystem: () => null;
 //# sourceMappingURL=window-animation-system.d.ts.map

package/dist/systems/window/window-animation-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-animation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-animation-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAiBrC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAqFT;AAQD,eAAO,MAAM,qBAAqB,YAoDjC,CAAA"}
+{"version":3,"file":"window-animation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-animation-system.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAiBrD,mGAAmG;AACnG,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CA2CzD;AAED,eAAO,MAAM,qBAAqB,YAGjC,CAAA"}

package/dist/systems/window/window-animation-system.js

@@ -1,147 +1,62 @@
 import { emitter, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { AWNING_WINDOW_SASH_NAME, CASEMENT_WINDOW_SASH_NAME, DOUBLE_HUNG_BOTTOM_SASH_NAME, DOUBLE_HUNG_TOP_SASH_NAME, FRENCH_CASEMENT_LEFT_SASH_NAME, FRENCH_CASEMENT_RIGHT_SASH_NAME, HOPPER_WINDOW_SASH_NAME, LOUVERED_WINDOW_SLATS_NAME, pendingWindowAnimationRebuilds, SINGLE_HUNG_ACTIVE_SASH_NAME, SLIDING_WINDOW_ACTIVE_PANEL_NAME, } from './window-system';
+import { poseWindowMovingParts, poseWindowShutters } from './window-pose';
+import { pendingWindowAnimationRebuilds } from './window-system';
+export { poseWindowMovingParts } from './window-pose';
 const easeWindowAnimation = (value) => value * value * (3 - 2 * value);
-/**
- * Pose a window's moving parts (sash/panel/slats) at `value` (0 = closed,
- * 1 = open) by mutating the named child groups under `mesh`. Returns true when
- * the window type has a direct pose path and the named parts were found.
- *
- * This is the single source of truth for window kinematics: the live animation
- * system poses the registered scene mesh, and the GLB exporter poses an export
- * clone to sample the open/close keyframes for a baked animation clip.
- */
-export function poseWindowMovingParts(node, mesh, value) {
-    if (node.windowType === 'sliding') {
-        const activePanel = mesh?.getObjectByName(SLIDING_WINDOW_ACTIVE_PANEL_NAME);
-        if (!activePanel)
-            return false;
-        const innerW = node.width - 2 * node.frameThickness;
-        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerW * 0.12);
-        const travel = Math.max(innerW / 2 - panelOverlap, 0) * value;
-        activePanel.position.x = -innerW / 4 - panelOverlap / 4 + travel;
-        return true;
-    }
-    if (node.windowType === 'single-hung') {
-        const activeSash = mesh?.getObjectByName(SINGLE_HUNG_ACTIVE_SASH_NAME);
-        if (!activeSash)
-            return false;
-        const innerH = node.height - 2 * node.frameThickness;
-        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerH * 0.12);
-        const travel = Math.max(innerH / 2 - panelOverlap, 0) * value;
-        activeSash.position.y = -innerH / 4 - panelOverlap / 4 + travel;
-        return true;
-    }
-    if (node.windowType === 'double-hung') {
-        const topSash = mesh?.getObjectByName(DOUBLE_HUNG_TOP_SASH_NAME);
-        const bottomSash = mesh?.getObjectByName(DOUBLE_HUNG_BOTTOM_SASH_NAME);
-        if (!(topSash && bottomSash))
-            return false;
-        const innerH = node.height - 2 * node.frameThickness;
-        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerH * 0.12);
-        const travel = Math.max(innerH / 2 - panelOverlap, 0) * value;
-        topSash.position.y = innerH / 4 + panelOverlap / 4 - travel;
-        bottomSash.position.y = -innerH / 4 - panelOverlap / 4 + travel;
-        return true;
-    }
-    if (node.windowType === 'louvered') {
-        const slats = mesh?.getObjectByName(LOUVERED_WINDOW_SLATS_NAME);
-        if (!slats)
-            return false;
-        const slatAngle = -value * (Math.PI / 3);
-        for (const slat of slats.children) {
-            slat.rotation.x = slatAngle;
-        }
-        return true;
-    }
-    if (node.windowType === 'casement') {
-        if ((node.casementStyle ?? 'single') === 'french') {
-            const leftSash = mesh?.getObjectByName(FRENCH_CASEMENT_LEFT_SASH_NAME);
-            const rightSash = mesh?.getObjectByName(FRENCH_CASEMENT_RIGHT_SASH_NAME);
-            if (!(leftSash && rightSash))
-                return false;
-            leftSash.rotation.y = -value * (Math.PI / 2);
-            rightSash.rotation.y = value * (Math.PI / 2);
-            return true;
-        }
-        const sash = mesh?.getObjectByName(CASEMENT_WINDOW_SASH_NAME);
-        if (!sash)
-            return false;
-        const hingeSign = (node.hingesSide ?? 'left') === 'left' ? -1 : 1;
-        sash.rotation.y = hingeSign * value * (Math.PI / 2);
-        return true;
-    }
-    if (node.windowType === 'awning') {
-        const sash = mesh?.getObjectByName(AWNING_WINDOW_SASH_NAME);
-        if (!sash)
-            return false;
-        sash.rotation.x = -value * (Math.PI / 3);
-        return true;
-    }
-    if (node.windowType === 'hopper') {
-        const sash = mesh?.getObjectByName(AWNING_WINDOW_SASH_NAME) ??
-            mesh?.getObjectByName(HOPPER_WINDOW_SASH_NAME);
-        if (!sash)
-            return false;
-        sash.rotation.x = -value * (Math.PI / 3);
-        return true;
-    }
-    return false;
-}
-function applyDirectWindowAnimation(windowId, value) {
-    const node = useScene.getState().nodes[windowId];
-    if (node?.type !== 'window')
+function applyDirectWindowAnimation(node, field, value) {
+    const mesh = sceneRegistry.nodes.get(node.id);
+    if (field === 'rollerShutterOpen')
         return false;
-    return poseWindowMovingParts(node, sceneRegistry.nodes.get(windowId), value);
+    if (field === 'shutterOpen')
+        return poseWindowShutters(node, mesh, value);
+    const shutterOpen = useInteractive.getState().windows[node.id]?.shutterOpen ?? node.shutterOpen ?? 1;
+    return poseWindowMovingParts(node, mesh, value, shutterOpen);
 }
-export const WindowAnimationSystem = () => {
-    useFrame(({ clock }) => {
-        const interactive = useInteractive.getState();
-        const entries = Object.entries(interactive.windowAnimations);
-        if (entries.length === 0)
-            return;
-        const now = clock.getElapsedTime() * 1000;
-        for (const [windowId, animation] of entries) {
-            const typedWindowId = windowId;
-            const scene = useScene.getState();
-            const node = scene.nodes[typedWindowId];
-            if (node?.type !== 'window') {
-                interactive.cancelWindowAnimation(typedWindowId);
-                interactive.removeWindowOpenState(typedWindowId);
-                continue;
-            }
+/** Advance the same viewer frame loop with an explicit clock for deterministic hosts and tests. */
+export function advanceWindowAnimations(now) {
+    const interactive = useInteractive.getState();
+    for (const [windowId, animations] of Object.entries(interactive.windowAnimations)) {
+        const typedWindowId = windowId;
+        const scene = useScene.getState();
+        const node = scene.nodes[typedWindowId];
+        if (node?.type !== 'window') {
+            interactive.cancelWindowAnimation(typedWindowId);
+            interactive.removeWindowOpenState(typedWindowId);
+            interactive.removeMechanismParts(typedWindowId);
+            pendingWindowAnimationRebuilds.delete(typedWindowId);
+            continue;
+        }
+        for (const animation of Object.values(animations)) {
             const startedAt = animation.startedAt ?? now;
             if (animation.startedAt === null) {
                 interactive.startWindowAnimation(typedWindowId, { ...animation, startedAt });
             }
-            const progress = Math.min(1, (now - startedAt) / animation.durationMs);
+            const progress = Math.min(1, Math.max(0, (now - startedAt) / animation.durationMs));
             const value = animation.from + (animation.to - animation.from) * easeWindowAnimation(progress);
             interactive.setWindowOpenState(typedWindowId, { [animation.field]: value });
-            const appliedDirectly = applyDirectWindowAnimation(typedWindowId, value);
-            // A dirty mark is one-shot work, not a needs-frame signal — per-tick
-            // marks kept the scene from ever settling. Types without a direct pose
-            // path get a transient rebuild request instead.
+            const appliedDirectly = applyDirectWindowAnimation(node, animation.field, value);
+            // A dirty mark is one-shot work, not a needs-frame signal. Variable
+            // topology (including roller slats) requests a transient rebuild instead.
             if (!appliedDirectly)
                 pendingWindowAnimationRebuilds.add(typedWindowId);
             if (progress < 1)
                 continue;
-            interactive.cancelWindowAnimation(typedWindowId);
+            interactive.cancelWindowAnimation(typedWindowId, animation.field);
             if (animation.persist) {
                 scene.updateNode(typedWindowId, { [animation.field]: animation.to });
-                interactive.removeWindowOpenState(typedWindowId);
-                // One-shot: the rebuild re-derives the pose from the persisted node.
-                scene.markDirty(typedWindowId);
-            }
-            else {
-                interactive.setWindowOpenState(typedWindowId, { [animation.field]: animation.to });
-                if (!appliedDirectly)
-                    scene.markDirty(typedWindowId);
+                interactive.removeWindowOpenState(typedWindowId, animation.field);
             }
+            // Rejoin the static batch at the settled pose, including preview-only runs.
+            scene.markDirty(typedWindowId);
             emitter.emit('window:animation-completed', {
                 windowId: typedWindowId,
                 field: animation.field,
             });
         }
-    }, 2);
+    }
+}
+export const WindowAnimationSystem = () => {
+    useFrame(({ clock }) => advanceWindowAnimations(clock.getElapsedTime() * 1000), 2);
     return null;
 };

package/dist/systems/window/window-pose.d.ts

@@ -0,0 +1,31 @@
+import { type WindowNode } from '@pascal-app/core';
+import type { Object3D } from 'three';
+export declare const WINDOW_LEFT_SHUTTER_NAME = "shutter-left";
+export declare const WINDOW_RIGHT_SHUTTER_NAME = "shutter-right";
+export declare const WINDOW_SHUTTER_OUTER_NAME = "shutter-outer";
+export declare const CASEMENT_WINDOW_SASH_NAME = "casement-window-sash";
+export declare const FRENCH_CASEMENT_LEFT_SASH_NAME = "french-casement-left-sash";
+export declare const FRENCH_CASEMENT_RIGHT_SASH_NAME = "french-casement-right-sash";
+export declare const SLIDING_WINDOW_ACTIVE_PANEL_NAME = "sliding-window-active-panel";
+export declare const SINGLE_HUNG_ACTIVE_SASH_NAME = "single-hung-active-sash";
+export declare const DOUBLE_HUNG_TOP_SASH_NAME = "double-hung-top-sash";
+export declare const DOUBLE_HUNG_BOTTOM_SASH_NAME = "double-hung-bottom-sash";
+export declare const LOUVERED_WINDOW_SLATS_NAME = "louvered-window-slats";
+export declare const AWNING_WINDOW_SASH_NAME = "awning-window-sash";
+export declare const HOPPER_WINDOW_SASH_NAME = "hopper-window-sash";
+export declare const TILT_TURN_WINDOW_SASH_NAME = "tilt-turn-window-sash";
+/** Cached in the built subtree so detached export clones keep the host's exterior direction. */
+export declare function windowExteriorSign(node: WindowNode, mesh?: Object3D): number;
+/** Leaves start along the wall in local X; bifolds stack perpendicular to it when open. */
+export declare function poseWindowShutters(node: WindowNode, mesh: Object3D | undefined, value: number): boolean;
+/**
+ * Pose a window's moving parts (sash/panel/slats) at `value` (0 = closed,
+ * 1 = open) by mutating the named child groups under `mesh`. Returns true when
+ * the window type has a direct pose path and the named parts were found.
+ *
+ * This is the single source of truth for window kinematics: the live animation
+ * system poses the registered scene mesh, and the GLB exporter poses an export
+ * clone to sample the open/close keyframes for a baked animation clip.
+ */
+export declare function poseWindowMovingParts(node: WindowNode, mesh: Object3D | undefined, value: number, shutterOpen?: number): boolean;
+//# sourceMappingURL=window-pose.d.ts.map

package/dist/systems/window/window-pose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-pose.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-pose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoD,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACpG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC,eAAO,MAAM,wBAAwB,iBAAiB,CAAA;AACtD,eAAO,MAAM,yBAAyB,kBAAkB,CAAA;AACxD,eAAO,MAAM,yBAAyB,kBAAkB,CAAA;AAExD,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAE3D,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AAEjE,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,MAAM,CAI5E;AAED,2FAA2F;AAC3F,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAiBT;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,MAA8B,GAC1C,OAAO,CA2GT"}

package/dist/systems/window/window-pose.js

@@ -0,0 +1,152 @@
+import { openingExteriorFace, openingHostFacing, useScene } from '@pascal-app/core';
+export const WINDOW_LEFT_SHUTTER_NAME = 'shutter-left';
+export const WINDOW_RIGHT_SHUTTER_NAME = 'shutter-right';
+export const WINDOW_SHUTTER_OUTER_NAME = 'shutter-outer';
+export const CASEMENT_WINDOW_SASH_NAME = 'casement-window-sash';
+export const FRENCH_CASEMENT_LEFT_SASH_NAME = 'french-casement-left-sash';
+export const FRENCH_CASEMENT_RIGHT_SASH_NAME = 'french-casement-right-sash';
+export const SLIDING_WINDOW_ACTIVE_PANEL_NAME = 'sliding-window-active-panel';
+export const SINGLE_HUNG_ACTIVE_SASH_NAME = 'single-hung-active-sash';
+export const DOUBLE_HUNG_TOP_SASH_NAME = 'double-hung-top-sash';
+export const DOUBLE_HUNG_BOTTOM_SASH_NAME = 'double-hung-bottom-sash';
+export const LOUVERED_WINDOW_SLATS_NAME = 'louvered-window-slats';
+export const AWNING_WINDOW_SASH_NAME = 'awning-window-sash';
+export const HOPPER_WINDOW_SASH_NAME = 'hopper-window-sash';
+export const TILT_TURN_WINDOW_SASH_NAME = 'tilt-turn-window-sash';
+/** Cached in the built subtree so detached export clones keep the host's exterior direction. */
+export function windowExteriorSign(node, mesh) {
+    if (typeof mesh?.userData.windowExteriorSign === 'number')
+        return mesh.userData.windowExteriorSign;
+    const face = openingExteriorFace(node, useScene.getState().nodes);
+    return (face === 'a' ? 1 : -1) * openingHostFacing(node);
+}
+/** Leaves start along the wall in local X; bifolds stack perpendicular to it when open. */
+export function poseWindowShutters(node, mesh, value) {
+    const exterior = windowExteriorSign(node, mesh);
+    let found = false;
+    for (const [name, side] of [
+        [WINDOW_LEFT_SHUTTER_NAME, -1],
+        [WINDOW_RIGHT_SHUTTER_NAME, 1],
+    ]) {
+        const leaf = mesh?.getObjectByName(name);
+        if (!leaf)
+            continue;
+        // Export clones can decompose a half-turn into nonzero X/Z Euler angles.
+        const outer = leaf.getObjectByName(WINDOW_SHUTTER_OUTER_NAME);
+        const swing = value * (outer ? Math.PI / 2 : Math.PI);
+        leaf.rotation.set(0, -side * exterior * (Math.PI - swing), 0);
+        if (outer)
+            outer.rotation.set(0, -side * exterior * 2 * swing, 0);
+        found = true;
+    }
+    return found;
+}
+/**
+ * Pose a window's moving parts (sash/panel/slats) at `value` (0 = closed,
+ * 1 = open) by mutating the named child groups under `mesh`. Returns true when
+ * the window type has a direct pose path and the named parts were found.
+ *
+ * This is the single source of truth for window kinematics: the live animation
+ * system poses the registered scene mesh, and the GLB exporter poses an export
+ * clone to sample the open/close keyframes for a baked animation clip.
+ */
+export function poseWindowMovingParts(node, mesh, value, shutterOpen = node.shutterOpen ?? 1) {
+    poseWindowShutters(node, mesh, shutterOpen);
+    if (node.windowType === 'sliding') {
+        const activePanel = mesh?.getObjectByName(SLIDING_WINDOW_ACTIVE_PANEL_NAME);
+        if (!activePanel)
+            return false;
+        const innerW = node.width - 2 * node.frameThickness;
+        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerW * 0.12);
+        const travel = Math.max(innerW / 2 - panelOverlap, 0) * value;
+        activePanel.position.x = -innerW / 4 - panelOverlap / 4 + travel;
+        return true;
+    }
+    if (node.windowType === 'single-hung') {
+        const activeSash = mesh?.getObjectByName(SINGLE_HUNG_ACTIVE_SASH_NAME);
+        if (!activeSash)
+            return false;
+        const innerH = node.height - 2 * node.frameThickness;
+        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerH * 0.12);
+        const travel = Math.max(innerH / 2 - panelOverlap, 0) * value;
+        activeSash.position.y = -innerH / 4 - panelOverlap / 4 + travel;
+        return true;
+    }
+    if (node.windowType === 'double-hung') {
+        const topSash = mesh?.getObjectByName(DOUBLE_HUNG_TOP_SASH_NAME);
+        const bottomSash = mesh?.getObjectByName(DOUBLE_HUNG_BOTTOM_SASH_NAME);
+        if (!(topSash && bottomSash))
+            return false;
+        const innerH = node.height - 2 * node.frameThickness;
+        const panelOverlap = Math.min(Math.max(node.frameThickness * 0.9, 0.04), innerH * 0.12);
+        const travel = Math.max(innerH / 2 - panelOverlap, 0) * value;
+        topSash.position.y = innerH / 4 + panelOverlap / 4 - travel;
+        bottomSash.position.y = -innerH / 4 - panelOverlap / 4 + travel;
+        return true;
+    }
+    if (node.windowType === 'louvered') {
+        const slats = mesh?.getObjectByName(LOUVERED_WINDOW_SLATS_NAME);
+        if (!slats)
+            return false;
+        const slatAngle = -value * (Math.PI / 3);
+        for (const slat of slats.children) {
+            slat.rotation.x = slatAngle;
+        }
+        return true;
+    }
+    const exterior = windowExteriorSign(node, mesh);
+    if (node.windowType === 'tilt-turn') {
+        const sash = mesh?.getObjectByName(TILT_TURN_WINDOW_SASH_NAME);
+        if (!sash)
+            return false;
+        sash.rotation.set(0, 0, 0);
+        if (node.tiltTurnMode === 'turn') {
+            sash.rotation.y = ((node.hingesSide === 'right' ? -1 : 1) * exterior * value * Math.PI) / 2;
+        }
+        else {
+            sash.rotation.x = (-exterior * value * Math.PI) / 12;
+        }
+        return true;
+    }
+    const direction = node.openingDirection === undefined
+        ? 1
+        : exterior * (node.openingDirection === 'inward' ? -1 : 1);
+    if (node.windowType === 'casement') {
+        if ((node.casementStyle ?? 'single') === 'french') {
+            const leftSash = mesh?.getObjectByName(FRENCH_CASEMENT_LEFT_SASH_NAME);
+            const rightSash = mesh?.getObjectByName(FRENCH_CASEMENT_RIGHT_SASH_NAME);
+            if (!(leftSash && rightSash))
+                return false;
+            leftSash.rotation.y = -direction * value * (Math.PI / 2);
+            rightSash.rotation.y = direction * value * (Math.PI / 2);
+            return true;
+        }
+        const sash = mesh?.getObjectByName(CASEMENT_WINDOW_SASH_NAME);
+        if (!sash)
+            return false;
+        const hingeSign = (node.hingesSide ?? 'left') === 'left' ? -1 : 1;
+        sash.rotation.y = direction * hingeSign * value * (Math.PI / 2);
+        return true;
+    }
+    if (node.windowType === 'awning') {
+        const sash = mesh?.getObjectByName(AWNING_WINDOW_SASH_NAME);
+        if (!sash)
+            return false;
+        sash.rotation.x =
+            (node.openingDirection === undefined
+                ? -1
+                : (node.awningDirection === 'down' ? 1 : -1) * direction) *
+                value *
+                (Math.PI / 3);
+        return true;
+    }
+    if (node.windowType === 'hopper') {
+        const sash = mesh?.getObjectByName(AWNING_WINDOW_SASH_NAME) ??
+            mesh?.getObjectByName(HOPPER_WINDOW_SASH_NAME);
+        if (!sash)
+            return false;
+        sash.rotation.x = -exterior * value * (Math.PI / 3);
+        return true;
+    }
+    return false;
+}

package/dist/systems/window/window-roller-shutter.d.ts

@@ -0,0 +1,8 @@
+import type { WindowNode } from '@pascal-app/core';
+import { Group, type Material, type Object3D } from 'three';
+/** Measure the closed unit in its own coordinates, including a surface-mounted roller box. */
+export declare function getWindowRollerCurtainZ(mesh: Object3D, exterior: number): number;
+export declare function buildWindowRollerCurtain(node: WindowNode, material: Material | Material[], z: number, open: number): Group;
+/** Export clones must use saved topology even when the live curtain is previewing another pose. */
+export declare function restoreWindowRollerShutter(node: WindowNode, mesh: Object3D): void;
+//# sourceMappingURL=window-roller-shutter.d.ts.map

package/dist/systems/window/window-roller-shutter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-roller-shutter.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-roller-shutter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAe,KAAK,EAAE,KAAK,QAAQ,EAAiB,KAAK,QAAQ,EAAW,MAAM,OAAO,CAAA;AAIhG,8FAA8F;AAC9F,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAsBhF;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,EAAE,EAC/B,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,GACX,KAAK,CAoBP;AAED,mGAAmG;AACnG,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAgBjF"}

package/dist/systems/window/window-roller-shutter.js

@@ -0,0 +1,64 @@
+import { BoxGeometry, Group, Matrix4, Mesh, Vector3 } from 'three';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
+/** Measure the closed unit in its own coordinates, including a surface-mounted roller box. */
+export function getWindowRollerCurtainZ(mesh, exterior) {
+    mesh.updateWorldMatrix(true, true);
+    const toWindow = mesh.matrixWorld.clone().invert();
+    const transform = new Matrix4();
+    const vertex = new Vector3();
+    let extent = 0;
+    mesh.traverse((part) => {
+        if (!(part instanceof Mesh) ||
+            part === mesh ||
+            (!['frame', 'glass', 'hardware'].includes(part.userData.slotId) &&
+                part.name !== 'window-roller-box'))
+            return;
+        transform.multiplyMatrices(toWindow, part.matrixWorld);
+        const position = part.geometry.getAttribute('position');
+        for (let i = 0; i < position.count; i++) {
+            vertex.fromBufferAttribute(position, i).applyMatrix4(transform);
+            extent = Math.max(extent, vertex.z * exterior);
+        }
+    });
+    return exterior * (extent + 0.015);
+}
+export function buildWindowRollerCurtain(node, material, z, open) {
+    const curtain = new Group();
+    curtain.name = 'window-roller-curtain';
+    curtain.position.z = z;
+    const width = node.width - (node.rollerShutter === 'concealed' ? 2 * 0.025 : 0);
+    const slatCount = Math.floor(((1 - open) * node.height) / 0.04);
+    if (slatCount <= 0)
+        return curtain;
+    const slats = [];
+    for (let i = 0; i < slatCount; i++) {
+        const slat = new BoxGeometry(width, 0.036, 0.01);
+        applyWorldScaleBoxUVs(slat, width, 0.036, 0.01);
+        slat.translate(0, node.height / 2 - i * 0.04 - 0.018, 0);
+        slats.push(slat);
+    }
+    const geometry = mergeGeometries(slats);
+    for (const slat of slats)
+        slat.dispose();
+    const panel = new Mesh(geometry, material);
+    panel.userData.slotId = 'shutters';
+    curtain.add(panel);
+    return curtain;
+}
+/** Export clones must use saved topology even when the live curtain is previewing another pose. */
+export function restoreWindowRollerShutter(node, mesh) {
+    if (node.rollerShutter !== 'box' && node.rollerShutter !== 'concealed')
+        return;
+    const curtain = mesh.getObjectByName('window-roller-curtain');
+    const guide = mesh.getObjectByName('window-roller-guide');
+    if (!curtain?.parent || !guide)
+        return;
+    const restored = buildWindowRollerCurtain(node, guide.material, curtain.position.z, node.rollerShutterOpen ?? 1);
+    curtain.parent.add(restored);
+    curtain.traverse((part) => {
+        if (part instanceof Mesh)
+            part.geometry.dispose();
+    });
+    curtain.removeFromParent();
+}

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

@@ -1,16 +1,7 @@
 import { type WindowNode } from '@pascal-app/core';
 import * as THREE from 'three';
-export declare const CASEMENT_WINDOW_SASH_NAME = "casement-window-sash";
-export declare const FRENCH_CASEMENT_LEFT_SASH_NAME = "french-casement-left-sash";
-export declare const FRENCH_CASEMENT_RIGHT_SASH_NAME = "french-casement-right-sash";
-export declare const SLIDING_WINDOW_ACTIVE_PANEL_NAME = "sliding-window-active-panel";
-export declare const SINGLE_HUNG_ACTIVE_SASH_NAME = "single-hung-active-sash";
-export declare const DOUBLE_HUNG_TOP_SASH_NAME = "double-hung-top-sash";
-export declare const DOUBLE_HUNG_BOTTOM_SASH_NAME = "double-hung-bottom-sash";
-export declare const LOUVERED_WINDOW_SLATS_NAME = "louvered-window-slats";
-export declare const AWNING_WINDOW_SASH_NAME = "awning-window-sash";
-export declare const HOPPER_WINDOW_SASH_NAME = "hopper-window-sash";
-export declare const pendingWindowAnimationRebuilds: Set<`block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`>;
+export * from './window-pose';
+export declare const pendingWindowAnimationRebuilds: Set<`beam_${string}` | `block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`>;
 export declare const WindowSystem: () => null;
 /**
  * Build a fresh window mesh for preview/ghost rendering.