@pascal-app/nodes 0.1.1

package/dist/cabinet/run-panel.d.ts

@@ -0,0 +1,17 @@
+import type { CabinetModuleNode as CabinetModuleNodeType, CabinetNode as CabinetNodeType } from '@pascal-app/core';
+import { useScene } from '@pascal-app/core';
+export type CabinetEditableNode = CabinetNodeType | CabinetModuleNodeType;
+export declare function bumpRunLayoutRevisionViaStore(scene: ReturnType<typeof useScene.getState>, run: CabinetNodeType): void;
+export declare function reflowRunModules({ modules, parentRun, patch, scene, selected, }: {
+    modules: CabinetModuleNodeType[];
+    parentRun: CabinetNodeType;
+    patch: Partial<CabinetModuleNodeType>;
+    scene: ReturnType<typeof useScene.getState>;
+    selected: CabinetModuleNodeType;
+}): void;
+export declare function CabinetRunPanel({ node, modules, onClose, }: {
+    node: CabinetNodeType;
+    modules: CabinetModuleNodeType[];
+    onClose: () => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=run-panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-panel.d.ts","sourceRoot":"","sources":["../../src/cabinet/run-panel.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,iBAAiB,IAAI,qBAAqB,EAC1C,WAAW,IAAI,eAAe,EAC/B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAkB,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AA6B3D,MAAM,MAAM,mBAAmB,GAAG,eAAe,GAAG,qBAAqB,CAAA;AA2CzE,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,EAC3C,GAAG,EAAE,eAAe,QAIrB;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,SAAS,EACT,KAAK,EACL,KAAK,EACL,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,qBAAqB,EAAE,CAAA;IAChC,SAAS,EAAE,eAAe,CAAA;IAC1B,KAAK,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAA;IACrC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC3C,QAAQ,EAAE,qBAAqB,CAAA;CAChC,QAmDA;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,OAAO,EACP,OAAO,GACR,EAAE;IACD,IAAI,EAAE,eAAe,CAAA;IACrB,OAAO,EAAE,qBAAqB,EAAE,CAAA;IAChC,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,+BA0YA"}

package/dist/cabinet/run-panel.js

@@ -0,0 +1,220 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { createSceneApi, useScene } from '@pascal-app/core';
+import { ActionButton, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Plus, Trash } from 'lucide-react';
+import { useCallback, useMemo } from 'react';
+import { addCabinetModuleSide, backAlignZ, bumpCabinetRunLayoutRevision, cornerLinkedSourceModuleForRun, runModuleBaseY, syncCornerRunsFromSourceModule, syncCornerStyleGroupFromRun, wallChildOf, } from './run-ops';
+import { backAnchoredModuleZ, minCabinetCarcassHeightForStack, reflowCabinetRunModules, stackForCabinet, } from './stack';
+const RUN_POSITION_PATCH_KEYS = new Set(['showPlinth', 'plinthHeight']);
+const RUN_MODULE_SYNC_PATCH_KEYS = new Set([
+    'frontStyle',
+    'frontOverlay',
+    'handleStyle',
+    'handlePosition',
+]);
+const RUN_DEPTH_PATCH_KEY = 'depth';
+const FRONT_STYLE_OPTIONS = [
+    { value: 'slab', label: 'Slab' },
+    { value: 'shaker', label: 'Shaker' },
+    { value: 'raised-arch', label: 'Raised Arch' },
+];
+const FRONT_OVERLAY_OPTIONS = [
+    { value: 'full', label: 'Overlay' },
+    { value: 'inset', label: 'Inset' },
+];
+const HANDLE_STYLE_OPTIONS = [
+    { value: 'bar', label: 'Bar' },
+    { value: 'knob', label: 'Knob' },
+    { value: 'cutout', label: 'Cutout' },
+    { value: 'hole', label: 'Hole' },
+    { value: 'none', label: 'None' },
+];
+const HANDLE_POSITION_OPTIONS = [
+    { value: 'auto', label: 'Auto' },
+    { value: 'top', label: 'Top' },
+    { value: 'center', label: 'Center' },
+];
+function moduleSummary(module) {
+    if ((module.cabinetType ?? 'base') === 'tall')
+        return 'Tall cabinet';
+    const stack = stackForCabinet(module);
+    if (stack.length === 0)
+        return 'Empty';
+    if (stack.length === 1)
+        return stack[0].type;
+    return `${stack.length} compartments`;
+}
+export function bumpRunLayoutRevisionViaStore(scene, run) {
+    bumpCabinetRunLayoutRevision(createSceneApi(useScene), run);
+    scene.markDirty(run.id);
+}
+export function reflowRunModules({ modules, parentRun, patch, scene, selected, }) {
+    const reflowed = reflowCabinetRunModules(modules, selected.id, patch.width ?? selected.width);
+    if (reflowed.length === 0)
+        return;
+    const reflowById = new Map(reflowed.map((entry) => [entry.id, entry]));
+    for (const module of [...modules].sort((a, b) => a.position[0] - b.position[0])) {
+        const reflow = reflowById.get(module.id);
+        if (!reflow)
+            continue;
+        const isSelected = module.id === selected.id;
+        const nextPatch = isSelected ? { ...patch } : {};
+        const nextPosition = [
+            reflow.position[0],
+            isSelected && patch.position ? patch.position[1] : reflow.position[1],
+            isSelected && typeof patch.depth === 'number'
+                ? backAnchoredModuleZ(module.position[2], module.depth, patch.depth)
+                : reflow.position[2],
+        ];
+        if (isSelected) {
+            const cabinetType = patch.cabinetType ?? module.cabinetType;
+            if (cabinetType === 'base') {
+                nextPatch.depth = patch.depth ?? parentRun.depth;
+                nextPatch.carcassHeight = patch.carcassHeight ?? parentRun.carcassHeight;
+                nextPatch.plinthHeight = patch.plinthHeight ?? parentRun.plinthHeight;
+                nextPatch.toeKickDepth = patch.toeKickDepth ?? parentRun.toeKickDepth;
+                nextPatch.countertopThickness = patch.countertopThickness ?? 0;
+                nextPatch.countertopOverhang = patch.countertopOverhang ?? parentRun.countertopOverhang;
+            }
+        }
+        nextPatch.position = nextPosition;
+        scene.updateNode(module.id, nextPatch);
+        const wallChild = wallChildOf(module, scene.nodes);
+        if (wallChild) {
+            scene.updateNode(wallChild.id, {
+                position: [
+                    0,
+                    wallChild.position[1],
+                    backAlignZ(nextPatch.depth ?? module.depth, wallChild.depth),
+                ],
+                width: reflow.width,
+            });
+            scene.markDirty(module.id);
+        }
+    }
+    bumpRunLayoutRevisionViaStore(scene, parentRun);
+}
+export function CabinetRunPanel({ node, modules, onClose, }) {
+    const setSelection = useViewer((s) => s.setSelection);
+    const sortedModules = useMemo(() => [...modules].sort((a, b) => a.position[0] - b.position[0]), [modules]);
+    const updateRun = useCallback((patch) => {
+        const scene = useScene.getState();
+        const sceneApi = createSceneApi(useScene);
+        const nextPatch = { ...patch };
+        if (typeof nextPatch.carcassHeight === 'number') {
+            const minModuleHeight = Math.max(0.4, ...modules.map((module) => minCabinetCarcassHeightForStack(module)));
+            nextPatch.carcassHeight = Math.max(nextPatch.carcassHeight, minModuleHeight);
+        }
+        const nextNode = { ...node, ...nextPatch };
+        scene.updateNode(node.id, nextPatch);
+        const shouldSyncDepth = RUN_DEPTH_PATCH_KEY in nextPatch;
+        const shouldSyncHeight = 'carcassHeight' in nextPatch;
+        const shouldSyncPosition = Object.keys(nextPatch).some((key) => RUN_POSITION_PATCH_KEYS.has(key));
+        const shouldSyncModules = Object.keys(nextPatch).some((key) => RUN_MODULE_SYNC_PATCH_KEYS.has(key));
+        if (!shouldSyncDepth && !shouldSyncHeight && !shouldSyncPosition && !shouldSyncModules)
+            return;
+        const stylePatch = {};
+        if ('frontStyle' in nextPatch)
+            stylePatch.frontStyle = nextNode.frontStyle;
+        if ('frontOverlay' in nextPatch)
+            stylePatch.frontOverlay = nextNode.frontOverlay;
+        if ('handleStyle' in nextPatch)
+            stylePatch.handleStyle = nextNode.handleStyle;
+        if ('handlePosition' in nextPatch)
+            stylePatch.handlePosition = nextNode.handlePosition;
+        for (const module of modules) {
+            const modulePatch = {};
+            if (shouldSyncDepth) {
+                modulePatch.depth = nextNode.depth;
+            }
+            if (shouldSyncHeight) {
+                modulePatch.carcassHeight = Math.max(nextNode.carcassHeight, minCabinetCarcassHeightForStack(module));
+            }
+            if (shouldSyncPosition) {
+                modulePatch.position = [module.position[0], runModuleBaseY(nextNode), module.position[2]];
+            }
+            if (shouldSyncModules) {
+                if ('frontStyle' in nextPatch)
+                    modulePatch.frontStyle = nextNode.frontStyle;
+                if ('frontOverlay' in nextPatch)
+                    modulePatch.frontOverlay = nextNode.frontOverlay;
+                if ('handleStyle' in nextPatch)
+                    modulePatch.handleStyle = nextNode.handleStyle;
+                if ('handlePosition' in nextPatch)
+                    modulePatch.handlePosition = nextNode.handlePosition;
+            }
+            scene.updateNode(module.id, modulePatch);
+            if (shouldSyncModules) {
+                const wallChild = wallChildOf(module, scene.nodes);
+                if (wallChild) {
+                    scene.updateNode(wallChild.id, {
+                        frontStyle: nextNode.frontStyle,
+                        frontOverlay: nextNode.frontOverlay,
+                        handleStyle: nextNode.handleStyle,
+                        handlePosition: nextNode.handlePosition,
+                    });
+                }
+            }
+        }
+        const cornerSource = cornerLinkedSourceModuleForRun(nextNode, scene.nodes);
+        if (shouldSyncModules) {
+            syncCornerStyleGroupFromRun({
+                run: nextNode,
+                patch: stylePatch,
+                sceneApi,
+            });
+        }
+        else if (cornerSource) {
+            syncCornerRunsFromSourceModule({
+                module: cornerSource,
+                run: nextNode,
+                sceneApi,
+            });
+        }
+    }, [modules, node]);
+    const addModule = useCallback((side) => {
+        const id = addCabinetModuleSide({
+            anchorModule: null,
+            run: node,
+            sceneApi: createSceneApi(useScene),
+            side,
+        });
+        if (id)
+            setSelection({ selectedIds: [id] });
+    }, [node, setSelection]);
+    const deleteModule = useCallback((module) => {
+        useScene.getState().deleteNode(module.id);
+        // Deleting the last module cascades the empty run away too — only
+        // keep it selected/dirty if it survived.
+        if (useScene.getState().nodes[node.id]) {
+            useScene.getState().markDirty(node.id);
+            setSelection({ selectedIds: [node.id] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [node.id, setSelection]);
+    return (_jsxs(PanelWrapper, { icon: "/icons/item.webp", onClose: onClose, title: node.name || 'Modular Cabinet', width: 320, children: [_jsxs(PanelSection, { title: "Modules", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-2", children: sortedModules.map((module, index) => (_jsxs("div", { className: "flex items-center justify-between rounded-lg border border-border/40 bg-[#252527] px-2 py-2", children: [_jsxs("button", { className: "min-w-0 flex-1 text-left", onClick: () => setSelection({ selectedIds: [module.id] }), type: "button", children: [_jsx("div", { className: "truncate text-xs font-medium text-foreground", children: module.name || `Module ${index + 1}` }), _jsx("div", { className: "text-[10px] uppercase tracking-wide text-muted-foreground", children: moduleSummary(module) })] }), _jsx("button", { className: "flex h-8 w-8 shrink-0 items-center justify-center rounded-md border border-red-500/20 bg-red-500/8 text-red-300 transition-colors hover:bg-red-500/15 hover:text-red-200 disabled:opacity-30", disabled: modules.length <= 1, onClick: () => deleteModule(module), type: "button", children: _jsx(Trash, { className: "h-3.5 w-3.5" }) })] }, module.id))) }), _jsx("div", { className: "px-1 pb-1", children: _jsxs("div", { className: "grid grid-cols-2 gap-2", children: [_jsx(ActionButton, { icon: _jsx(Plus, { className: "h-4 w-4" }), label: "Add left", onClick: () => addModule('left') }), _jsx(ActionButton, { icon: _jsx(Plus, { className: "h-4 w-4" }), label: "Add right", onClick: () => addModule('right') })] }) })] }), _jsx(PanelSection, { title: "Shared Plinth & Countertop", children: _jsxs("div", { className: "space-y-2 px-1 pb-2", children: [_jsx(SliderControl, { label: "Depth", max: 1.2, min: 0.3, onChange: (value) => updateRun({ depth: value }), precision: 2, step: 0.01, unit: "m", value: node.depth }), _jsx(SliderControl, { label: "Carcass height", max: node.runTier === 'tall' ? 2.4 : 1.4, min: Math.max(0.4, ...modules.map((module) => minCabinetCarcassHeightForStack(module))), onChange: (value) => updateRun({ carcassHeight: value }), precision: 2, step: 0.01, unit: "m", value: node.carcassHeight }), _jsx(ToggleControl, { checked: node.showPlinth, label: "Show plinth", onChange: (checked) => updateRun({ showPlinth: checked }) }), node.showPlinth && (_jsx(SliderControl, { label: "Plinth height", max: 0.3, min: 0.02, onChange: (value) => updateRun({ plinthHeight: value }), precision: 2, step: 0.01, unit: "m", value: node.plinthHeight })), _jsx(ToggleControl, { checked: node.withCountertop, label: "Show countertop", onChange: (checked) => updateRun({ withCountertop: checked }) }), node.withCountertop && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Countertop height", max: 0.08, min: 0.005, onChange: (value) => updateRun({ countertopThickness: value }), precision: 3, step: 0.005, unit: "m", value: node.countertopThickness }), _jsx(SliderControl, { label: "Countertop depth", max: 0.12, min: 0, onChange: (value) => updateRun({ countertopOverhang: value }), precision: 2, step: 0.005, unit: "m", value: node.countertopOverhang })] }))] }) }), _jsx(PanelSection, { title: "Island & Bar", children: _jsxs("div", { className: "space-y-2 px-1 pb-2", children: [node.withCountertop && node.barLedge?.edge !== 'back' && (_jsx(SliderControl, { label: "Seating overhang", max: 0.45, min: 0, onChange: (value) => updateRun({ countertopBackOverhang: value }), precision: 2, step: 0.05, unit: "m", value: node.countertopBackOverhang })), _jsx(ToggleControl, { checked: node.withFinishedBack, label: "Finished back", onChange: (checked) => updateRun({ withFinishedBack: checked }) }), node.withCountertop && (_jsx(ToggleControl, { checked: node.withWaterfall, label: "Waterfall ends", onChange: (checked) => updateRun({ withWaterfall: checked }) })), _jsx(ToggleControl, { checked: Boolean(node.barLedge), label: "Bar counter", onChange: (checked) => updateRun({
+                                barLedge: checked ? { edge: 'back', height: 1.06, depth: 0.35 } : undefined,
+                            }) }), node.barLedge && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (value) => updateRun({
+                                        barLedge: { ...node.barLedge, edge: value },
+                                    }), options: [
+                                        { value: 'back', label: 'Back' },
+                                        { value: 'left', label: 'Left' },
+                                        { value: 'right', label: 'Right' },
+                                    ], value: node.barLedge.edge }), _jsx(SliderControl, { label: "Bar height", max: 1.3, min: 0.9, onChange: (value) => updateRun({ barLedge: { ...node.barLedge, height: value } }), precision: 2, step: 0.01, unit: "m", value: node.barLedge.height }), _jsx(SliderControl, { label: "Bar depth", max: 0.5, min: 0.15, onChange: (value) => updateRun({ barLedge: { ...node.barLedge, depth: value } }), precision: 2, step: 0.01, unit: "m", value: node.barLedge.depth })] }))] }) }), _jsx(PanelSection, { title: "Fronts", children: _jsxs("div", { className: "space-y-2 px-1 pb-2", children: [_jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] uppercase tracking-wide text-muted-foreground", children: "Style" }), _jsx(SegmentedControl, { onChange: (value) => updateRun({ frontStyle: value }), options: FRONT_STYLE_OPTIONS.map((option) => ({
+                                        value: option.value,
+                                        label: option.label,
+                                    })), value: node.frontStyle ?? 'slab' })] }), _jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] uppercase tracking-wide text-muted-foreground", children: "Mounting" }), _jsx(SegmentedControl, { onChange: (value) => updateRun({ frontOverlay: value }), options: FRONT_OVERLAY_OPTIONS.map((option) => ({
+                                        value: option.value,
+                                        label: option.label,
+                                    })), value: node.frontOverlay ?? 'full' })] })] }) }), _jsx(PanelSection, { title: "Handles", children: _jsxs("div", { className: "space-y-2 px-1 pb-2", children: [_jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] uppercase tracking-wide text-muted-foreground", children: "Style" }), _jsx(SegmentedControl, { onChange: (value) => updateRun({ handleStyle: value }), options: HANDLE_STYLE_OPTIONS.map((option) => ({
+                                        value: option.value,
+                                        label: option.label,
+                                    })), value: node.handleStyle })] }), (node.handleStyle === 'bar' || node.handleStyle === 'knob') && (_jsxs("div", { children: [_jsx("div", { className: "px-1 pb-1 text-[10px] uppercase tracking-wide text-muted-foreground", children: "Position" }), _jsx(SegmentedControl, { onChange: (value) => updateRun({ handlePosition: value }), options: HANDLE_POSITION_OPTIONS.map((option) => ({
+                                        value: option.value,
+                                        label: option.label,
+                                    })), value: node.handlePosition ?? 'auto' })] }))] }) })] }));
+}

package/dist/cabinet/scene-action.d.ts

@@ -0,0 +1,8 @@
+import type { SceneActionCapability } from '@pascal-app/core';
+export type CabinetCooktopKnobTarget = {
+    type: 'gas';
+    compartmentIndex: number;
+    burnerIndex: number;
+};
+export declare const cabinetSceneAction: SceneActionCapability;
+//# sourceMappingURL=scene-action.d.ts.map

package/dist/cabinet/scene-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-action.d.ts","sourceRoot":"","sources":["../../src/cabinet/scene-action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,qBAAqB,EAAY,MAAM,kBAAkB,CAAA;AAU3F,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,KAAK,CAAA;IACX,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAiKD,eAAO,MAAM,kBAAkB,EAAE,qBAIhC,CAAA"}

package/dist/cabinet/scene-action.js

@@ -0,0 +1,130 @@
+import { getEffectiveNode, useLiveNodeOverrides } from '@pascal-app/core';
+import { compartmentCooktopActiveBurners, compartmentCooktopElementCount, compartmentCooktopKnobProgress, patchCompartment, } from './stack';
+const KNOB_TURN_DURATION_MS = 180;
+let knobAnimationId = 0;
+const activeKnobAnimations = new Map();
+function knobTargetFromUserData(userData) {
+    const target = userData.cabinetCooktopKnob;
+    if (target?.type === 'gas' &&
+        Number.isInteger(target.compartmentIndex) &&
+        Number.isInteger(target.burnerIndex) &&
+        target.compartmentIndex >= 0 &&
+        target.burnerIndex >= 0) {
+        return target;
+    }
+    return null;
+}
+function gasCompartmentAt(node, compartmentIndex) {
+    const stack = node.stack;
+    if (!Array.isArray(stack))
+        return null;
+    const compartment = stack[compartmentIndex];
+    if (!compartment || typeof compartment !== 'object')
+        return null;
+    if (compartment.type !== 'cooktop-gas')
+        return null;
+    return { stack: stack, compartment };
+}
+function withCooktopBurnerProgress(node, target, progress, nextActiveBurners) {
+    const resolved = gasCompartmentAt(node, target.compartmentIndex);
+    if (!resolved)
+        return null;
+    const { stack, compartment } = resolved;
+    const nextProgress = compartmentCooktopKnobProgress(patchCompartment(compartment, { cooktopActiveBurners: [...nextActiveBurners] }), 'cooktop-gas');
+    nextProgress[target.burnerIndex] = Math.max(0, Math.min(1, progress));
+    return {
+        stack: stack.map((entry, index) => index === target.compartmentIndex
+            ? patchCompartment(entry, {
+                cooktopBurnersOn: nextActiveBurners.length > 0,
+                cooktopActiveBurners: [...nextActiveBurners],
+                cooktopKnobProgress: nextProgress,
+            })
+            : entry),
+    };
+}
+function activeBurnersWithTarget(compartment, target, active) {
+    const current = compartmentCooktopActiveBurners(compartment, 'cooktop-gas');
+    const withoutTarget = current.filter((index) => index !== target.burnerIndex);
+    return active ? [...withoutTarget, target.burnerIndex].sort((a, b) => a - b) : withoutTarget;
+}
+function startKnobAnimation(nodeId) {
+    const key = nodeId;
+    const id = ++knobAnimationId;
+    const active = activeKnobAnimations.get(key) ?? new Set();
+    active.add(id);
+    activeKnobAnimations.set(key, active);
+    return id;
+}
+function finishKnobAnimation(nodeId, id) {
+    const key = nodeId;
+    const active = activeKnobAnimations.get(key);
+    if (!active)
+        return true;
+    active.delete(id);
+    if (active.size > 0)
+        return false;
+    activeKnobAnimations.delete(key);
+    return true;
+}
+/**
+ * Toggle one gas burner. The knob eases over ~180ms by publishing transient
+ * stack patches through `useLiveNodeOverrides` (+ dirty marks so the geometry
+ * rebuilds each frame), then commits the final state once — a single undo step.
+ */
+function toggleCabinetCooktopKnob(node, target, sceneApi) {
+    const resolved = gasCompartmentAt(node, target.compartmentIndex);
+    if (!resolved)
+        return false;
+    const { compartment } = resolved;
+    const count = compartmentCooktopElementCount(compartment, 'cooktop-gas');
+    if (target.burnerIndex >= count)
+        return false;
+    const activeBurners = compartmentCooktopActiveBurners(compartment, 'cooktop-gas');
+    const wasActive = activeBurners.includes(target.burnerIndex);
+    const from = compartmentCooktopKnobProgress(compartment, 'cooktop-gas')[target.burnerIndex] ?? 0;
+    const to = wasActive ? 0 : 1;
+    const nodeId = node.id;
+    const startedAt = performance.now();
+    const animationId = startKnobAnimation(nodeId);
+    const buildPatch = (progress) => {
+        const latest = sceneApi.get(nodeId);
+        const effectiveNode = getEffectiveNode(latest ?? node);
+        const latestCompartment = gasCompartmentAt(effectiveNode, target.compartmentIndex)?.compartment;
+        if (!latestCompartment)
+            return null;
+        return withCooktopBurnerProgress(effectiveNode, target, progress, activeBurnersWithTarget(latestCompartment, target, !wasActive));
+    };
+    const tick = (time) => {
+        const elapsed = Math.max(0, time - startedAt);
+        const t = Math.min(1, elapsed / KNOB_TURN_DURATION_MS);
+        const eased = 1 - (1 - t) ** 3;
+        const progress = from + (to - from) * eased;
+        const patch = buildPatch(progress);
+        if (patch) {
+            useLiveNodeOverrides.getState().set(nodeId, patch);
+            sceneApi.markDirty(nodeId);
+        }
+        if (t < 1) {
+            requestAnimationFrame(tick);
+            return;
+        }
+        const finalPatch = buildPatch(to);
+        const shouldClearOverride = finishKnobAnimation(nodeId, animationId);
+        if (finalPatch) {
+            sceneApi.update(nodeId, finalPatch);
+        }
+        else {
+            sceneApi.markDirty(nodeId);
+        }
+        if (shouldClearOverride)
+            useLiveNodeOverrides.getState().clear(nodeId);
+    };
+    requestAnimationFrame(tick);
+    return true;
+}
+// Exposed with the default `unknown` target: `activate` only ever receives
+// what this capability's own `resolveTarget` returned, so the narrow is safe.
+export const cabinetSceneAction = {
+    resolveTarget: (object) => knobTargetFromUserData(object.userData),
+    activate: (node, target, sceneApi) => toggleCabinetCooktopKnob(node, target, sceneApi),
+};

package/dist/cabinet/schema.d.ts

@@ -0,0 +1,2 @@
+export { CabinetModuleNode, CabinetNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/cabinet/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/cabinet/schema.js

@@ -0,0 +1 @@
+export { CabinetModuleNode, CabinetNode } from '@pascal-app/core';

package/dist/cabinet/slots.d.ts

@@ -0,0 +1,4 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+export type CabinetSlotId = 'front' | 'carcass' | 'countertop' | 'plinth' | 'hardware' | 'glass' | 'appliance' | 'applianceInterior';
+export declare function cabinetSlots(): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/cabinet/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,aAAa,GACrB,OAAO,GACP,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,OAAO,GACP,WAAW,GACX,mBAAmB,CAAA;AAWvB,wBAAgB,YAAY,IAAI,eAAe,EAAE,CAehD"}

package/dist/cabinet/slots.js

@@ -0,0 +1,24 @@
+const FRONT_DEFAULT = 'library:preset-softwhite';
+const CARCASS_DEFAULT = 'library:preset-softwhite';
+const COUNTERTOP_DEFAULT = 'library:wood-finewood27';
+const PLINTH_DEFAULT = 'library:preset-softwhite';
+const HARDWARE_DEFAULT = 'library:metal-chrome';
+const GLASS_DEFAULT = 'library:preset-glass';
+const APPLIANCE_DEFAULT = 'library:metal-steel';
+const APPLIANCE_INTERIOR_DEFAULT = 'library:preset-charcoal';
+export function cabinetSlots() {
+    return [
+        { slotId: 'front', label: 'Front', default: FRONT_DEFAULT },
+        { slotId: 'carcass', label: 'Carcass', default: CARCASS_DEFAULT },
+        { slotId: 'countertop', label: 'Countertop', default: COUNTERTOP_DEFAULT },
+        { slotId: 'plinth', label: 'Plinth', default: PLINTH_DEFAULT },
+        { slotId: 'hardware', label: 'Hardware', default: HARDWARE_DEFAULT },
+        { slotId: 'glass', label: 'Glass', default: GLASS_DEFAULT },
+        { slotId: 'appliance', label: 'Appliance', default: APPLIANCE_DEFAULT },
+        {
+            slotId: 'applianceInterior',
+            label: 'Appliance Interior',
+            default: APPLIANCE_INTERIOR_DEFAULT,
+        },
+    ];
+}

package/dist/cabinet/stack-transitions.d.ts

@@ -0,0 +1,12 @@
+import type { CabinetModuleNode as CabinetModuleNodeType, CabinetNode as CabinetNodeType } from '@pascal-app/core';
+import { type CabinetCompartment } from './stack';
+export declare function resolveCompartmentTransition({ node, parentRun, index, next, }: {
+    node: CabinetNodeType | CabinetModuleNodeType;
+    parentRun: CabinetNodeType | undefined;
+    index: number;
+    next: CabinetCompartment;
+}): {
+    stack: CabinetCompartment[];
+    modulePatch: Partial<CabinetModuleNodeType>;
+};
+//# sourceMappingURL=stack-transitions.d.ts.map

package/dist/cabinet/stack-transitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-transitions.d.ts","sourceRoot":"","sources":["../../src/cabinet/stack-transitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,IAAI,qBAAqB,EAC1C,WAAW,IAAI,eAAe,EAC/B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,KAAK,kBAAkB,EAsBxB,MAAM,SAAS,CAAA;AAOhB,wBAAgB,4BAA4B,CAAC,EAC3C,IAAI,EACJ,SAAS,EACT,KAAK,EACL,IAAI,GACL,EAAE;IACD,IAAI,EAAE,eAAe,GAAG,qBAAqB,CAAA;IAC7C,SAAS,EAAE,eAAe,GAAG,SAAS,CAAA;IACtC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,kBAAkB,CAAA;CACzB,GAAG;IAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAA;CAAE,CAqH/E"}

package/dist/cabinet/stack-transitions.js

@@ -0,0 +1,112 @@
+import { resolveCabinetType } from './run-ops';
+import { COOKTOP_STANDARD_WIDTH, cooktopCabinetStack, DISHWASHER_STANDARD_HEIGHT, DISHWASHER_STANDARD_WIDTH, FRIDGE_COLUMN_WIDTH, FRIDGE_WIDE_WIDTH, fridgeCabinetStack, hoodCompartmentHeight, isCooktopCompartmentType, isFridgeCompartmentType, isHoodCompartmentType, MICROWAVE_STANDARD_WIDTH, PULL_OUT_PANTRY_STANDARD_WIDTH, replaceCabinetCompartmentStack, SINK_STANDARD_WIDTH, sinkCabinetStack, stackForCabinet, TALL_CABINET_CARCASS_HEIGHT, } from './stack';
+const BASE_MODULE_WIDTH = 0.6;
+const BASE_CARCASS_HEIGHT = 0.72;
+const WALL_CARCASS_HEIGHT = 0.72;
+const TALL_CARCASS_HEIGHT = TALL_CABINET_CARCASS_HEIGHT;
+export function resolveCompartmentTransition({ node, parentRun, index, next, }) {
+    const stack = stackForCabinet(node);
+    const current = stack[index];
+    const leavingFridge = current ? isFridgeCompartmentType(current.type) : false;
+    const enteringFridge = isFridgeCompartmentType(next.type);
+    const enteringCooktop = isCooktopCompartmentType(next.type);
+    const enteringSink = next.type === 'sink';
+    const leavingPullOutPantry = current?.type === 'pull-out-pantry';
+    const enteringPullOutPantry = next.type === 'pull-out-pantry';
+    const leavingHood = current ? isHoodCompartmentType(current.type) : false;
+    const enteringHood = isHoodCompartmentType(next.type);
+    const enteringSingleDishwasher = next.type === 'dishwasher' && stack.length === 1;
+    const hoodModulePatch = enteringHood
+        ? {
+            carcassHeight: Math.max(0.4, hoodCompartmentHeight(next.type)),
+            countertopThickness: 0,
+            countertopOverhang: 0,
+            showPlinth: false,
+            withCountertop: false,
+        }
+        : leavingHood
+            ? { carcassHeight: WALL_CARCASS_HEIGHT }
+            : {};
+    const tallApplianceModulePatch = enteringFridge || enteringPullOutPantry
+        ? {
+            cabinetType: 'tall',
+            width: enteringPullOutPantry
+                ? PULL_OUT_PANTRY_STANDARD_WIDTH
+                : next.type === 'fridge-double'
+                    ? FRIDGE_WIDE_WIDTH
+                    : FRIDGE_COLUMN_WIDTH,
+            depth: parentRun?.depth ?? 0.58,
+            carcassHeight: TALL_CARCASS_HEIGHT,
+            plinthHeight: 0.1,
+            toeKickDepth: 0.075,
+            countertopThickness: 0,
+            countertopOverhang: parentRun?.countertopOverhang ?? 0.02,
+            showPlinth: false,
+            withCountertop: false,
+        }
+        : {};
+    const standardModulePatch = (leavingFridge || leavingPullOutPantry) && !enteringFridge && !enteringPullOutPantry
+        ? {
+            cabinetType: 'base',
+            width: next.type === 'microwave'
+                ? MICROWAVE_STANDARD_WIDTH
+                : next.type === 'dishwasher'
+                    ? DISHWASHER_STANDARD_WIDTH
+                    : enteringCooktop
+                        ? COOKTOP_STANDARD_WIDTH
+                        : BASE_MODULE_WIDTH,
+            depth: parentRun?.depth ?? 0.58,
+            carcassHeight: parentRun?.carcassHeight ?? BASE_CARCASS_HEIGHT,
+            plinthHeight: parentRun?.plinthHeight ?? 0.1,
+            toeKickDepth: parentRun?.toeKickDepth ?? 0.075,
+            countertopThickness: 0,
+            countertopOverhang: parentRun?.countertopOverhang ?? 0.02,
+            showPlinth: false,
+            withCountertop: false,
+        }
+        : {};
+    const dishwasherModulePatch = enteringSingleDishwasher
+        ? {
+            cabinetType: 'base',
+            width: DISHWASHER_STANDARD_WIDTH,
+            depth: parentRun?.depth ?? 0.58,
+            carcassHeight: DISHWASHER_STANDARD_HEIGHT,
+            plinthHeight: parentRun?.plinthHeight ?? 0.1,
+            toeKickDepth: parentRun?.toeKickDepth ?? 0.075,
+            countertopThickness: 0,
+            countertopOverhang: parentRun?.countertopOverhang ?? 0.02,
+            showPlinth: false,
+            withCountertop: false,
+        }
+        : {};
+    return {
+        stack: enteringFridge
+            ? fridgeCabinetStack(next.type)
+            : enteringCooktop && stack.length === 1
+                ? cooktopCabinetStack(next.type)
+                : enteringSink && stack.length === 1
+                    ? sinkCabinetStack()
+                    : enteringPullOutPantry
+                        ? [{ ...next, height: TALL_CARCASS_HEIGHT }]
+                        : enteringHood
+                            ? [next]
+                            : replaceCabinetCompartmentStack(node, index, next, node.type === 'cabinet-module' && resolveCabinetType(node, parentRun) === 'base'
+                                ? 'drawer'
+                                : 'door'),
+        modulePatch: {
+            ...tallApplianceModulePatch,
+            ...standardModulePatch,
+            ...dishwasherModulePatch,
+            ...hoodModulePatch,
+            ...(next.type === 'microwave' ? { width: MICROWAVE_STANDARD_WIDTH } : {}),
+            ...(next.type === 'dishwasher' ? { width: DISHWASHER_STANDARD_WIDTH } : {}),
+            ...(enteringCooktop ? { width: COOKTOP_STANDARD_WIDTH } : {}),
+            ...(enteringSink ? { width: SINK_STANDARD_WIDTH } : {}),
+            ...(enteringPullOutPantry ? { width: PULL_OUT_PANTRY_STANDARD_WIDTH } : {}),
+            ...(isFridgeCompartmentType(next.type) && next.type !== 'fridge-double'
+                ? { width: FRIDGE_COLUMN_WIDTH }
+                : {}),
+            ...(next.type === 'fridge-double' ? { width: FRIDGE_WIDE_WIDTH } : {}),
+        },
+    };
+}