@pascal-app/nodes 0.1.1

package/dist/cabinet/geometry.js

@@ -0,0 +1,219 @@
+import { Group } from 'three';
+import { addCooktopCompartment } from './geometry/cooktop';
+import { addDishwasherCompartment } from './geometry/dishwasher';
+import { addFridgeCompartment } from './geometry/fridge';
+import { addDoorFronts, addDrawerFronts, addShelfBoards, addSinkFalseFront, } from './geometry/fronts';
+import { addRangeHoodCompartment } from './geometry/hood';
+import { addApplianceCompartment } from './geometry/oven-microwave';
+import { addPullOutPantryCompartment } from './geometry/pantry';
+import { buildCabinetRunGeometry } from './geometry/run';
+import { addBox, getCabinetSlotMaterials } from './geometry/shared';
+import { addSinkCompartment, cutSinkIntoCountertop, sinkBowls } from './geometry/sink';
+import { compartmentDoorType, compartmentDrawerCount, compartmentShelfCount, compartmentSinkLayout, isHoodCompartmentType, normalizeCabinetStack, stackForCabinet, } from './stack';
+const CORNER_FILLER_TOP_INSET = 0.001;
+const CORNER_FILLER_SIDE_INSET = 0.001;
+const WALL_CORNER_FILLER_FRONT_HEIGHT_INSET = 0.001;
+const SINK_FALSE_FRONT_HEIGHT = 0.22;
+export function buildCabinetGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    if (node.type === 'cabinet') {
+        const run = buildCabinetRunGeometry(node, ctx, shading, textures, colorPreset, sceneTheme);
+        if (run)
+            return run;
+        return new Group();
+    }
+    const group = new Group();
+    const materials = getCabinetSlotMaterials(node, ctx, shading, textures, colorPreset, sceneTheme);
+    const hoodRows = normalizeCabinetStack(node);
+    if (hoodRows.length > 0 && hoodRows.every((row) => isHoodCompartmentType(row.compartment.type))) {
+        const hoodPlinth = node.showPlinth ? node.plinthHeight : 0;
+        hoodRows.forEach((row) => {
+            addRangeHoodCompartment(group, node, materials, row.compartment.type, hoodPlinth + row.y0, row.height, ctx, row.index);
+        });
+        return group;
+    }
+    const width = node.width;
+    const depth = node.depth;
+    const board = node.boardThickness;
+    const plinth = node.showPlinth ? node.plinthHeight : 0;
+    const toeKickDepth = node.showPlinth ? Math.min(node.toeKickDepth, depth - board * 2) : 0;
+    const carcassHeight = node.carcassHeight;
+    const frontThickness = node.frontThickness;
+    const frontGap = node.frontGap;
+    const countertopThickness = node.withCountertop ? node.countertopThickness : 0;
+    const countertopOverhang = node.withCountertop ? node.countertopOverhang : 0;
+    const bodyCenterY = plinth + carcassHeight / 2;
+    const topY = plinth + carcassHeight;
+    const bottomLift = node.withBottomPanel ? board : 0;
+    const backThickness = Math.min(0.006, board / 2);
+    const backInset = Math.min(0.012, depth * 0.08);
+    const frontRecess = 0.0015;
+    const inset = node.frontOverlay === 'inset';
+    const insetInteriorClearance = inset ? Math.max(0.012, frontThickness + frontRecess + 0.006) : 0;
+    // Overlay fronts sit proud on the carcass face; inset fronts sit flush within the opening.
+    const frontZ = inset
+        ? depth / 2 - frontThickness / 2 - frontRecess
+        : depth / 2 + frontThickness / 2 - frontRecess;
+    const openLeft = node.openSide === 'left';
+    const openRight = node.openSide === 'right';
+    const innerLeft = -width / 2 + (openLeft ? 0 : board);
+    const innerRight = width / 2 - (openRight ? 0 : board);
+    const innerWidth = Math.max(0.01, innerRight - innerLeft);
+    const innerCenterX = (innerLeft + innerRight) / 2;
+    const openingWidth = innerWidth;
+    const openingDepth = Math.max(0.01, depth - backInset - 0.02 - insetInteriorClearance);
+    const drawerBoxBackZ = -depth / 2 + backInset + 0.02;
+    const drawerBoxFrontZ = frontZ - frontThickness / 2 - 0.001 - insetInteriorClearance;
+    const drawerBoxDepth = Math.max(0.05, drawerBoxFrontZ - drawerBoxBackZ);
+    const parentRun = ctx?.parent?.type === 'cabinet' ? ctx.parent : null;
+    const isWallCornerFiller = node.moduleKind === 'corner-filler' && parentRun?.runTier === 'wall';
+    if (node.moduleKind === 'corner-filler') {
+        const filler = new Group();
+        const shelfDepth = Math.max(0.01, depth - backInset - 0.02);
+        const shelfCount = Math.max(1, stackForCabinet(node)
+            .filter((compartment) => compartment.type === 'door')
+            .reduce((best, compartment) => Math.max(best, compartmentShelfCount(compartment)), 0));
+        if (!openLeft) {
+            const leftSideInset = isWallCornerFiller && openRight ? CORNER_FILLER_SIDE_INSET / 2 : 0;
+            addBox(filler, [board, carcassHeight, depth], [-width / 2 + board / 2 + leftSideInset, bodyCenterY, 0], materials.carcass, 'cabinet-corner-filler-side-left', 'carcass');
+        }
+        if (!openRight) {
+            const rightSideInset = isWallCornerFiller && openLeft ? CORNER_FILLER_SIDE_INSET / 2 : 0;
+            addBox(filler, [board, carcassHeight, depth], [width / 2 - board / 2 - rightSideInset, bodyCenterY, 0], materials.carcass, 'cabinet-corner-filler-side-right', 'carcass');
+        }
+        if (node.withBottomPanel) {
+            addBox(filler, [innerWidth, board, depth - backInset], [innerCenterX, plinth + board / 2, backInset / 2], materials.carcass, 'cabinet-corner-filler-bottom', 'carcass');
+        }
+        // Keep open-side corner-filler tops just inside the shared boundary so
+        // neighboring wall-top fillers/cabinets don't land coplanar and shimmer.
+        const topLeft = innerLeft + (openLeft ? CORNER_FILLER_TOP_INSET : 0);
+        const topRight = innerRight - (openRight ? CORNER_FILLER_TOP_INSET : 0);
+        addBox(filler, [Math.max(0.01, topRight - topLeft), board, depth], [(topLeft + topRight) / 2, topY - board / 2, 0], materials.carcass, 'cabinet-corner-filler-top', 'carcass');
+        addBox(filler, [innerWidth, Math.max(0.001, carcassHeight - board), backThickness], [innerCenterX, plinth + carcassHeight / 2, -depth / 2 + backInset + backThickness / 2], materials.carcass, 'cabinet-corner-filler-back', 'carcass');
+        const frontExtension = board / 2 + frontGap;
+        const wallFrontSharedInset = isWallCornerFiller ? frontThickness + frontGap : 0;
+        const frontLeft = -width / 2 -
+            (openLeft ? frontExtension : 0) +
+            (isWallCornerFiller && openRight ? wallFrontSharedInset : 0);
+        const frontRight = width / 2 +
+            (openRight ? frontExtension : 0) -
+            (isWallCornerFiller && openLeft ? wallFrontSharedInset : 0);
+        const frontWidth = Math.max(0.01, frontRight - frontLeft);
+        const frontHeight = isWallCornerFiller
+            ? Math.max(0.01, carcassHeight - WALL_CORNER_FILLER_FRONT_HEIGHT_INSET * 2)
+            : carcassHeight;
+        addBox(filler, [frontWidth, frontHeight, frontThickness], [(frontLeft + frontRight) / 2, bodyCenterY, frontZ], materials.front, 'cabinet-corner-filler-front', 'front');
+        if (node.cornerShelf) {
+            addShelfBoards(filler, materials, innerWidth, shelfDepth, board, plinth + board, Math.max(0.01, carcassHeight - board * 2), shelfCount, innerCenterX);
+        }
+        return filler;
+    }
+    const rows = normalizeCabinetStack(node);
+    const sinkRow = rows.find((row) => row.compartment.type === 'sink');
+    const sinkBowlSpecs = sinkRow
+        ? sinkBowls(compartmentSinkLayout(sinkRow.compartment), innerWidth, depth)
+        : null;
+    if (!openLeft) {
+        addBox(group, [board, carcassHeight, depth], [-width / 2 + board / 2, bodyCenterY, 0], materials.carcass, 'cabinet-side-left', 'carcass');
+    }
+    if (!openRight) {
+        addBox(group, [board, carcassHeight, depth], [width / 2 - board / 2, bodyCenterY, 0], materials.carcass, 'cabinet-side-right', 'carcass');
+    }
+    if (node.withBottomPanel) {
+        addBox(group, [innerWidth, board, depth - backInset], [innerCenterX, plinth + board / 2, backInset / 2], materials.carcass, 'cabinet-bottom', 'carcass');
+    }
+    // Sink bases skip the top panel — the basin hangs through that plane.
+    if (!sinkRow) {
+        addBox(group, [innerWidth, board, depth], [innerCenterX, topY - board / 2, 0], materials.carcass, 'cabinet-top', 'carcass');
+    }
+    if (node.showPlinth && plinth > 0) {
+        addBox(group, [width - board * 2, plinth, Math.max(board, depth - toeKickDepth)], [0, plinth / 2, -(toeKickDepth / 2)], materials.plinth, 'cabinet-plinth', 'plinth');
+    }
+    if (node.withCountertop && countertopThickness > 0) {
+        const countertop = addBox(group, [width + countertopOverhang * 2, countertopThickness, depth + countertopOverhang], [0, topY + countertopThickness / 2, 0.01], materials.countertop, 'cabinet-countertop', 'countertop');
+        if (sinkBowlSpecs) {
+            group.remove(countertop);
+            const cut = cutSinkIntoCountertop(countertop, sinkBowlSpecs, 0, 0, countertopThickness);
+            countertop.geometry.dispose();
+            group.add(cut);
+        }
+    }
+    if (sinkBowlSpecs && sinkRow) {
+        // Modules inside a run don't own a countertop (the run draws and cuts
+        // it), so the faucet rises above the run's slab thickness instead.
+        const slabThickness = countertopThickness > 0
+            ? countertopThickness
+            : parentRun?.withCountertop
+                ? parentRun.countertopThickness
+                : 0.02;
+        addSinkCompartment(group, sinkBowlSpecs, 0, 0, topY, slabThickness, sinkRow.index, materials.appliance);
+        const falseFrontHeight = Math.min(Math.max(0.01, carcassHeight - frontGap * 2), SINK_FALSE_FRONT_HEIGHT);
+        addSinkFalseFront(group, node, materials, inset ? openingWidth : Math.max(0.01, width - frontGap), falseFrontHeight, topY - falseFrontHeight / 2, frontZ, sinkRow.index);
+    }
+    rows.forEach((row, index) => {
+        // Sink rows are zero-height; the basin/faucet render against the
+        // countertop plane above, so the row contributes no carcass geometry.
+        if (row.compartment.type === 'sink')
+            return;
+        if (row.compartment.type === 'cooktop-gas' || row.compartment.type === 'cooktop-induction') {
+            const countertopClearance = 0.001;
+            const effectiveCountertopThickness = Math.max(countertopThickness, 0.02);
+            addCooktopCompartment(group, node, row.compartment, row.compartment.type, topY + effectiveCountertopThickness + countertopClearance, index);
+            return;
+        }
+        const isFirst = index === 0;
+        const isLast = index === rows.length - 1;
+        const bottomOccupancy = isFirst ? bottomLift : board / 2;
+        const topOccupancy = isLast ? board : board / 2;
+        const subCellBottomY = plinth + row.y0;
+        const openingBottomY = subCellBottomY + bottomOccupancy;
+        const openingHeight = Math.max(0.01, row.height - bottomOccupancy - topOccupancy);
+        const openingCenterY = openingBottomY + openingHeight / 2;
+        addBox(group, [openingWidth, Math.max(0.001, row.height - board), backThickness], [innerCenterX, subCellBottomY + row.height / 2, -depth / 2 + backInset + backThickness / 2], materials.carcass, `cabinet-back-${index}`, 'carcass');
+        // No deck below a sink row — the basin hangs through that plane.
+        if (index < rows.length - 1 && rows[index + 1].compartment.type !== 'sink') {
+            const deckY = plinth + row.y1;
+            addBox(group, [openingWidth, board, openingDepth], [innerCenterX, deckY, board / 2], materials.carcass, `cabinet-deck-${index}`, 'carcass');
+        }
+        const faceWidth = inset ? openingWidth : Math.max(0.01, width - frontGap);
+        const faceHeight = inset ? openingHeight : Math.max(0.01, row.height);
+        const faceCenterY = inset ? openingCenterY : subCellBottomY + row.height / 2;
+        if (row.compartment.type === 'door') {
+            addDoorFronts(group, node, materials, faceWidth, faceHeight, 0, faceCenterY, frontZ, compartmentDoorType(row.compartment, node.width));
+            if ((row.compartment.shelfCount ?? 0) > 0) {
+                addShelfBoards(group, materials, openingWidth, openingDepth, board, openingBottomY, openingHeight, row.compartment.shelfCount ?? 0, innerCenterX);
+            }
+            return;
+        }
+        if (row.compartment.type === 'shelf') {
+            addShelfBoards(group, materials, openingWidth, openingDepth, board, openingBottomY, openingHeight, compartmentShelfCount(row.compartment), innerCenterX);
+            return;
+        }
+        if (row.compartment.type === 'drawer') {
+            addDrawerFronts(group, node, materials, faceWidth, faceHeight, faceCenterY, inset ? openingBottomY : subCellBottomY, openingWidth, frontZ, compartmentDrawerCount(row.compartment), drawerBoxBackZ, drawerBoxDepth);
+            return;
+        }
+        if (row.compartment.type === 'dishwasher') {
+            addDishwasherCompartment(group, node, materials, faceWidth, faceHeight, faceCenterY, openingWidth, openingDepth, frontZ, index);
+            return;
+        }
+        if (row.compartment.type === 'pull-out-pantry') {
+            addPullOutPantryCompartment(group, node, materials, faceWidth, faceHeight, faceCenterY, openingWidth, openingDepth, frontZ, row.compartment, index);
+            return;
+        }
+        if (row.compartment.type === 'oven' || row.compartment.type === 'microwave') {
+            addApplianceCompartment(group, node, materials, row.compartment.type, faceWidth, faceHeight, faceCenterY, openingWidth, openingDepth, frontZ, index);
+            return;
+        }
+        if (row.compartment.type === 'fridge-single' ||
+            row.compartment.type === 'fridge-double' ||
+            row.compartment.type === 'fridge-top-freezer' ||
+            row.compartment.type === 'fridge-bottom-freezer') {
+            addFridgeCompartment(group, node, materials, row.compartment.type, faceWidth, faceHeight, faceCenterY, openingWidth, openingDepth, frontZ, index);
+            return;
+        }
+        if (isHoodCompartmentType(row.compartment.type)) {
+            addRangeHoodCompartment(group, node, materials, row.compartment.type, plinth + row.y0, row.height, ctx, index);
+        }
+    });
+    return group;
+}

package/dist/cabinet/index.d.ts

@@ -0,0 +1,5 @@
+export { bakeCabinetAnimationClip, poseCabinetMovingParts } from './animation';
+export { cabinetDefinition, cabinetModuleDefinition } from './definition';
+export { default as useCabinetPlacementStatus } from './placement-status';
+export { type CabinetPlacementType, default as useCabinetPlacementType, } from './placement-type';
+//# sourceMappingURL=index.d.ts.map

package/dist/cabinet/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cabinet/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AACzE,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,OAAO,IAAI,uBAAuB,GACnC,MAAM,kBAAkB,CAAA"}

package/dist/cabinet/index.js

@@ -0,0 +1,4 @@
+export { bakeCabinetAnimationClip, poseCabinetMovingParts } from './animation';
+export { cabinetDefinition, cabinetModuleDefinition } from './definition';
+export { default as useCabinetPlacementStatus } from './placement-status';
+export { default as useCabinetPlacementType, } from './placement-type';

package/dist/cabinet/interaction.d.ts

@@ -0,0 +1,15 @@
+import { type AnyNodeId } from '@pascal-app/core';
+/** Subscribe to animation start/stop, e.g. for the panel's Play/Stop button. */
+export declare function onCabinetAnimationChange(listener: (nodeId: string, running: boolean) => void): () => void;
+export declare function isCabinetAnimationRunning(nodeId: AnyNodeId): boolean;
+/** Cancel an in-flight animation, committing the current live frame once. */
+export declare function stopCabinetAnimation(nodeId: AnyNodeId): void;
+export declare function animateCabinetOperationState(nodeId: AnyNodeId, target: 0 | 1): void;
+/**
+ * E-key interaction: animate toward open when mostly closed, toward closed
+ * when mostly open. Pressing E mid-animation reverses from the live frame.
+ * On a run, every child module swings together (the run's own
+ * `operationState` doesn't pose module doors — each module owns its own).
+ */
+export declare function toggleCabinetOperationState(nodeId: AnyNodeId): void;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/cabinet/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../src/cabinet/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkC,MAAM,kBAAkB,CAAA;AAuBjF,gFAAgF;AAChF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,cAK5F;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAEpE;AAOD,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,QAarD;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,QA+C5E;AAOD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,QAsB5D"}

package/dist/cabinet/interaction.js

@@ -0,0 +1,109 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { isFridgeCompartmentType, stackForCabinet } from './stack';
+const activeAnimations = new Map();
+const listeners = new Set();
+function notify(nodeId, running) {
+    for (const listener of listeners)
+        listener(nodeId, running);
+}
+/** Subscribe to animation start/stop, e.g. for the panel's Play/Stop button. */
+export function onCabinetAnimationChange(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+export function isCabinetAnimationRunning(nodeId) {
+    return activeAnimations.has(nodeId);
+}
+function isCabinetLike(nodeId) {
+    const node = useScene.getState().nodes[nodeId];
+    return node?.type === 'cabinet' || node?.type === 'cabinet-module' ? node : null;
+}
+/** Cancel an in-flight animation, committing the current live frame once. */
+export function stopCabinetAnimation(nodeId) {
+    const animation = activeAnimations.get(nodeId);
+    if (!animation)
+        return;
+    window.cancelAnimationFrame(animation.frame);
+    activeAnimations.delete(nodeId);
+    const overrides = useLiveNodeOverrides.getState();
+    const liveValue = overrides.get(nodeId)?.operationState;
+    if (typeof liveValue === 'number' && isCabinetLike(nodeId)) {
+        useScene.getState().updateNode(nodeId, { operationState: liveValue });
+    }
+    overrides.clearFields(nodeId, ['operationState']);
+    notify(nodeId, false);
+}
+export function animateCabinetOperationState(nodeId, target) {
+    const existing = activeAnimations.get(nodeId);
+    if (existing) {
+        window.cancelAnimationFrame(existing.frame);
+        activeAnimations.delete(nodeId);
+    }
+    const node = isCabinetLike(nodeId);
+    if (!node)
+        return;
+    const overrides = useLiveNodeOverrides.getState();
+    const liveValue = overrides.get(nodeId)?.operationState;
+    const start = typeof liveValue === 'number' ? liveValue : (node.operationState ?? 0);
+    if (Math.abs(start - target) < 1e-4) {
+        overrides.clearFields(nodeId, ['operationState']);
+        useScene.getState().updateNode(nodeId, { operationState: target });
+        return;
+    }
+    // Fridge doors are heavy — swing a touch slower.
+    const hasFridge = stackForCabinet(node).some((compartment) => isFridgeCompartmentType(compartment.type));
+    const duration = hasFridge ? 450 : 320;
+    const startTime = window.performance.now();
+    const step = (time) => {
+        const animation = activeAnimations.get(nodeId);
+        if (!animation)
+            return;
+        const t = Math.min(1, (time - startTime) / duration);
+        const eased = 1 - (1 - t) ** 3;
+        const nextValue = start + (target - start) * eased;
+        if (t < 1) {
+            useLiveNodeOverrides.getState().set(nodeId, { operationState: nextValue });
+            animation.frame = window.requestAnimationFrame(step);
+            return;
+        }
+        activeAnimations.delete(nodeId);
+        useScene.getState().updateNode(nodeId, { operationState: target });
+        useLiveNodeOverrides.getState().clearFields(nodeId, ['operationState']);
+        notify(nodeId, false);
+    };
+    activeAnimations.set(nodeId, { frame: window.requestAnimationFrame(step) });
+    notify(nodeId, true);
+}
+function effectiveOperationState(nodeId, nodeValue) {
+    const liveValue = useLiveNodeOverrides.getState().get(nodeId)?.operationState;
+    return typeof liveValue === 'number' ? liveValue : (nodeValue ?? 0);
+}
+/**
+ * E-key interaction: animate toward open when mostly closed, toward closed
+ * when mostly open. Pressing E mid-animation reverses from the live frame.
+ * On a run, every child module swings together (the run's own
+ * `operationState` doesn't pose module doors — each module owns its own).
+ */
+export function toggleCabinetOperationState(nodeId) {
+    const node = isCabinetLike(nodeId);
+    if (!node)
+        return;
+    if (node.type === 'cabinet') {
+        const nodes = useScene.getState().nodes;
+        const modules = (node.children ?? [])
+            .map((id) => nodes[id])
+            .filter((child) => child?.type === 'cabinet-module');
+        if (modules.length === 0)
+            return;
+        const anyOpen = modules.some((module) => effectiveOperationState(module.id, module.operationState) >= 0.5);
+        const target = anyOpen ? 0 : 1;
+        for (const module of modules) {
+            animateCabinetOperationState(module.id, target);
+        }
+        return;
+    }
+    const current = effectiveOperationState(nodeId, node.operationState);
+    animateCabinetOperationState(nodeId, current >= 0.5 ? 0 : 1);
+}

package/dist/cabinet/move-frame.d.ts

@@ -0,0 +1,3 @@
+import type { MovableParentFrame } from '@pascal-app/core';
+export declare const cabinetModuleParentFrame: MovableParentFrame;
+//# sourceMappingURL=move-frame.d.ts.map

package/dist/cabinet/move-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-frame.d.ts","sourceRoot":"","sources":["../../src/cabinet/move-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AAiSzB,eAAO,MAAM,wBAAwB,EAAE,kBAgCtC,CAAA"}

package/dist/cabinet/move-frame.js

@@ -0,0 +1,252 @@
+import { planToRunLocal, runLocalToPlan } from './run-layout';
+import { bumpCabinetRunLayoutRevision, syncCornerRunsFromSourceModule } from './run-ops';
+/** Matches the generic move tool's Figma-alignment pull (8 cm). */
+const MAGNETIC_THRESHOLD_M = 0.08;
+const GUIDE_EPSILON_M = 1e-4;
+function runParent(node, nodes) {
+    if (node.type !== 'cabinet-module' || !node.parentId)
+        return null;
+    const parent = nodes[node.parentId];
+    return parent?.type === 'cabinet' ? parent : null;
+}
+function isCabinetFrameNode(node) {
+    return node?.type === 'cabinet' || node?.type === 'cabinet-module';
+}
+function nodeRotationY(node) {
+    const rotation = node.rotation;
+    if (typeof rotation === 'number')
+        return rotation;
+    if (Array.isArray(rotation))
+        return rotation[1] ?? 0;
+    return 0;
+}
+function composePlanTransform(parent, child) {
+    const cos = Math.cos(parent.rotation);
+    const sin = Math.sin(parent.rotation);
+    const [x, y, z] = child.position;
+    return {
+        position: [
+            parent.position[0] + x * cos + z * sin,
+            parent.position[1] + y,
+            parent.position[2] - x * sin + z * cos,
+        ],
+        rotation: parent.rotation + child.rotation,
+    };
+}
+function frameWorldTransform(node, nodes, visited = new Set()) {
+    const own = {
+        position: [...node.position],
+        rotation: nodeRotationY(node),
+    };
+    if (!nodes || !node.parentId || visited.has(node.id))
+        return own;
+    visited.add(node.id);
+    const parent = nodes[node.parentId];
+    if (!isCabinetFrameNode(parent))
+        return own;
+    return composePlanTransform(frameWorldTransform(parent, nodes, visited), own);
+}
+function localToPlan(parent, local, nodes) {
+    const run = parent;
+    if (!nodes || !run.parentId || !isCabinetFrameNode(nodes[run.parentId])) {
+        return runLocalToPlan(run, local);
+    }
+    const transform = frameWorldTransform(run, nodes);
+    const cos = Math.cos(transform.rotation);
+    const sin = Math.sin(transform.rotation);
+    const [lx, ly, lz] = local;
+    return [
+        transform.position[0] + lx * cos + lz * sin,
+        transform.position[1] + ly,
+        transform.position[2] - lx * sin + lz * cos,
+    ];
+}
+function planToLocal(parent, planX, localY, planZ, nodes) {
+    const run = parent;
+    if (!nodes || !run.parentId || !isCabinetFrameNode(nodes[run.parentId])) {
+        return planToRunLocal(run, planX, localY, planZ);
+    }
+    const transform = frameWorldTransform(run, nodes);
+    const dx = planX - transform.position[0];
+    const dz = planZ - transform.position[2];
+    const cos = Math.cos(transform.rotation);
+    const sin = Math.sin(transform.rotation);
+    return [dx * cos - dz * sin, localY, dx * sin + dz * cos];
+}
+/**
+ * Edge-mating snap between sibling modules in the run's local frame: pull the
+ * dragged module flush against a sibling's side when within the magnetic
+ * threshold, and align depth (Z center / front / back) when width bands touch.
+ */
+function magneticSnap(node, parent, local, nodes) {
+    const run = parent;
+    const moving = node;
+    const movingHalfWidth = moving.width / 2;
+    const movingHalfDepth = moving.depth / 2;
+    const movingMinX = local[0] - movingHalfWidth;
+    const movingMaxX = local[0] + movingHalfWidth;
+    const movingMinZ = local[2] - movingHalfDepth;
+    const movingMaxZ = local[2] + movingHalfDepth;
+    let bestDeltaX = 0;
+    let bestDistanceX = Number.POSITIVE_INFINITY;
+    let bestDeltaZ = 0;
+    let bestDistanceZ = Number.POSITIVE_INFINITY;
+    const considerX = (delta) => {
+        const distance = Math.abs(delta);
+        if (distance > MAGNETIC_THRESHOLD_M)
+            return;
+        if (distance < bestDistanceX) {
+            bestDeltaX = delta;
+            bestDistanceX = distance;
+        }
+    };
+    const considerZ = (delta) => {
+        const distance = Math.abs(delta);
+        if (distance > MAGNETIC_THRESHOLD_M)
+            return;
+        if (distance < bestDistanceZ) {
+            bestDeltaZ = delta;
+            bestDistanceZ = distance;
+        }
+    };
+    for (const childId of run.children ?? []) {
+        if (childId === node.id)
+            continue;
+        const sibling = nodes[childId];
+        if (sibling?.type !== 'cabinet-module')
+            continue;
+        const module = sibling;
+        const siblingHalfWidth = module.width / 2;
+        const siblingHalfDepth = module.depth / 2;
+        const siblingMinX = module.position[0] - siblingHalfWidth;
+        const siblingMaxX = module.position[0] + siblingHalfWidth;
+        const siblingMinZ = module.position[2] - siblingHalfDepth;
+        const siblingMaxZ = module.position[2] + siblingHalfDepth;
+        const depthBandsTouch = movingMinZ <= siblingMaxZ + MAGNETIC_THRESHOLD_M &&
+            movingMaxZ >= siblingMinZ - MAGNETIC_THRESHOLD_M;
+        if (depthBandsTouch) {
+            considerX(siblingMinX - movingMaxX);
+            considerX(siblingMaxX - movingMinX);
+        }
+        const widthBandsTouch = movingMinX <= siblingMaxX + MAGNETIC_THRESHOLD_M &&
+            movingMaxX >= siblingMinX - MAGNETIC_THRESHOLD_M;
+        if (widthBandsTouch) {
+            considerZ(module.position[2] - local[2]);
+            considerZ(siblingMinZ - movingMinZ);
+            considerZ(siblingMaxZ - movingMaxZ);
+        }
+    }
+    if (!Number.isFinite(bestDistanceX) && !Number.isFinite(bestDistanceZ)) {
+        return [local[0], local[1], local[2]];
+    }
+    return [local[0] + bestDeltaX, local[1], local[2] + bestDeltaZ];
+}
+function planPoint(parent, localX, localZ, nodes) {
+    const [x, , z] = localToPlan(parent, [localX, 0, localZ], nodes);
+    return { x, z };
+}
+function makeSnapMatch({ axis, candidateNodeId, from, to, }) {
+    return {
+        axis,
+        candidateNodeId,
+        from,
+        to,
+    };
+}
+function magneticSnapMatches(node, parent, _local, snappedLocal, nodes) {
+    const run = parent;
+    const moving = node;
+    const movingHalfWidth = moving.width / 2;
+    const movingHalfDepth = moving.depth / 2;
+    const movingMinX = snappedLocal[0] - movingHalfWidth;
+    const movingMaxX = snappedLocal[0] + movingHalfWidth;
+    const movingMinZ = snappedLocal[2] - movingHalfDepth;
+    const movingMaxZ = snappedLocal[2] + movingHalfDepth;
+    const matches = [];
+    for (const childId of run.children ?? []) {
+        if (matches.length >= 2)
+            break;
+        if (childId === node.id)
+            continue;
+        const sibling = nodes[childId];
+        if (sibling?.type !== 'cabinet-module')
+            continue;
+        const module = sibling;
+        const siblingHalfWidth = module.width / 2;
+        const siblingHalfDepth = module.depth / 2;
+        const siblingMinX = module.position[0] - siblingHalfWidth;
+        const siblingMaxX = module.position[0] + siblingHalfWidth;
+        const siblingMinZ = module.position[2] - siblingHalfDepth;
+        const siblingMaxZ = module.position[2] + siblingHalfDepth;
+        if (matches.every((match) => match.axis !== 'x') &&
+            movingMinZ <= siblingMaxZ + MAGNETIC_THRESHOLD_M &&
+            movingMaxZ >= siblingMinZ - MAGNETIC_THRESHOLD_M) {
+            const sharedX = Math.abs(movingMinX - siblingMaxX) <= GUIDE_EPSILON_M
+                ? movingMinX
+                : Math.abs(movingMaxX - siblingMinX) <= GUIDE_EPSILON_M
+                    ? movingMaxX
+                    : null;
+            if (sharedX !== null) {
+                matches.push(makeSnapMatch({
+                    axis: 'x',
+                    candidateNodeId: module.id,
+                    from: planPoint(parent, sharedX, Math.min(movingMinZ, siblingMinZ), nodes),
+                    to: planPoint(parent, sharedX, Math.max(movingMaxZ, siblingMaxZ), nodes),
+                }));
+            }
+        }
+        if (matches.every((match) => match.axis !== 'z') &&
+            movingMinX <= siblingMaxX + MAGNETIC_THRESHOLD_M &&
+            movingMaxX >= siblingMinX - MAGNETIC_THRESHOLD_M) {
+            const sharedZ = Math.abs(snappedLocal[2] - module.position[2]) <= GUIDE_EPSILON_M
+                ? snappedLocal[2]
+                : Math.abs(movingMinZ - siblingMinZ) <= GUIDE_EPSILON_M
+                    ? movingMinZ
+                    : Math.abs(movingMaxZ - siblingMaxZ) <= GUIDE_EPSILON_M
+                        ? movingMaxZ
+                        : null;
+            if (sharedZ !== null) {
+                matches.push(makeSnapMatch({
+                    axis: 'z',
+                    candidateNodeId: module.id,
+                    from: planPoint(parent, Math.min(movingMinX, siblingMinX), sharedZ, nodes),
+                    to: planPoint(parent, Math.max(movingMaxX, siblingMaxX), sharedZ, nodes),
+                }));
+            }
+        }
+    }
+    return matches;
+}
+export const cabinetModuleParentFrame = {
+    resolveParent: runParent,
+    parentRotationY: (parent, nodes) => frameWorldTransform(parent, nodes).rotation,
+    localToPlan,
+    planToLocal,
+    magneticSnap,
+    magneticSnapMatches,
+    // Module position isn't in the run's geometryKey, so a committed move must
+    // bump the layout revision to re-flow spans/countertop — and re-anchor any
+    // linked L-corner runs to the module's new edge.
+    onCommit: (node, parent, sceneApi) => {
+        if (node.type !== 'cabinet-module' || parent.type !== 'cabinet')
+            return;
+        bumpCabinetRunLayoutRevision(sceneApi, parent);
+        syncCornerRunsFromSourceModule({
+            module: node,
+            run: sceneApi.get(parent.id) ?? parent,
+            sceneApi,
+        });
+    },
+    floorplanLiveTransform: ({ node, live }) => {
+        const rotation = node.rotation;
+        return {
+            ...node,
+            position: live.position,
+            rotation: Array.isArray(rotation)
+                ? [rotation[0] ?? 0, live.rotation, rotation[2] ?? 0]
+                : typeof rotation === 'number'
+                    ? live.rotation
+                    : rotation,
+        };
+    },
+};

package/dist/cabinet/paint.d.ts

@@ -0,0 +1,2 @@
+export declare const cabinetPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/cabinet/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/cabinet/paint.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,4CAcvB,CAAA"}

package/dist/cabinet/paint.js

@@ -0,0 +1,17 @@
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+export const cabinetPaint = createSlotPaintCapability({
+    materialTarget: 'cabinet',
+    resolveRole: ({ hitObject }) => {
+        const slotId = hitObject?.userData?.slotId;
+        return typeof slotId === 'string' ? slotId : null;
+    },
+    applyPreview: previewGeometrySlot,
+    legacyEffective: (node, role) => {
+        if (role === 'hardware')
+            return null;
+        return {
+            material: node.material,
+            materialPreset: node.materialPreset,
+        };
+    },
+});

package/dist/cabinet/panel.d.ts

@@ -0,0 +1,2 @@
+export default function CabinetPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

package/dist/cabinet/panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cabinet/panel.tsx"],"names":[],"mappings":"AA2FA,MAAM,CAAC,OAAO,UAAU,YAAY,uCA2jBnC"}