@pascal-app/nodes 0.1.1

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

@@ -0,0 +1,15 @@
+import { type CabinetModuleNode as CabinetModuleNodeType, type FloorplanMoveTarget } from '@pascal-app/core';
+/**
+ * 2D floor-plan move for a cabinet module — the parity twin of the 3D
+ * `movable.parentFrame` path. A module's `position` is run-local (rotated
+ * frame), so the generic overlay translate — which writes plan-space
+ * coordinates — teleports modules of any rotated / offset run and skips
+ * sibling edge-mating. Each tick: grid-snap the cursor in plan frame,
+ * convert through `planToLocal`, magnet against sibling modules, write the
+ * local position, and bump the run's layout revision so spans / countertop
+ * re-flow live (module position is not in the run's geometryKey). History is
+ * paused by the overlay; its snapshot-diff commit makes the drag one undo
+ * step covering both the module and the run metadata.
+ */
+export declare const cabinetModuleFloorplanMoveTarget: FloorplanMoveTarget<CabinetModuleNodeType>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/cabinet/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,IAAI,qBAAqB,EAG/C,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AA8GzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,qBAAqB,CAiHvF,CAAA"}

package/dist/cabinet/floorplan-move.js

@@ -0,0 +1,192 @@
+import { createSceneApi, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { cabinetModuleParentFrame } from './move-frame';
+import { bumpCabinetRunLayoutRevision, syncCornerRunsFromSourceModule } from './run-ops';
+import { resolveCabinetModuleWallSnapLocal } from './wall-snap';
+function alignmentGuideFromParentFrameMatch(match) {
+    return {
+        axis: match.axis,
+        coord: match.axis === 'x' ? match.from.x : match.from.z,
+        from: match.from,
+        to: match.to,
+        anchor: match.from,
+        movingAnchorKind: 'corner',
+        candidateAnchorKind: 'corner',
+        candidateNodeId: match.candidateNodeId,
+        distance: Math.hypot(match.to.x - match.from.x, match.to.z - match.from.z),
+    };
+}
+function mergeSceneUpdate(updates, id, patch) {
+    updates.set(id, {
+        ...(updates.get(id) ?? {}),
+        ...patch,
+    });
+}
+function collectCabinetModuleMoveCommitUpdates({ lastLocal, moduleId, runId, }) {
+    const baseNodes = useScene.getState().nodes;
+    const nodes = { ...baseNodes };
+    const updates = new Map();
+    let unsupportedMutation = false;
+    const sceneApi = {
+        get(id) {
+            return nodes[id];
+        },
+        nodes() {
+            return nodes;
+        },
+        update(id, patch) {
+            const current = nodes[id];
+            if (!current)
+                return;
+            nodes[id] = { ...current, ...patch };
+            mergeSceneUpdate(updates, id, patch);
+        },
+        upsert(node) {
+            if (!nodes[node.id]) {
+                unsupportedMutation = true;
+                return node.id;
+            }
+            nodes[node.id] = node;
+            mergeSceneUpdate(updates, node.id, node);
+            return node.id;
+        },
+        delete() {
+            unsupportedMutation = true;
+        },
+        restore() { },
+        restoreAll() { },
+        markDirty() { },
+        pauseHistory() { },
+        resumeHistory() { },
+        getSubtree() {
+            return null;
+        },
+        cloneNodesInto() {
+            unsupportedMutation = true;
+            return null;
+        },
+    };
+    sceneApi.update(moduleId, { position: lastLocal });
+    const liveRun = sceneApi.get(runId);
+    if (liveRun?.type !== 'cabinet')
+        return Array.from(updates, ([id, data]) => ({ id, data }));
+    bumpCabinetRunLayoutRevision(sceneApi, liveRun);
+    const liveModule = sceneApi.get(moduleId);
+    if (liveModule?.type === 'cabinet-module') {
+        syncCornerRunsFromSourceModule({
+            module: liveModule,
+            run: sceneApi.get(runId) ?? liveRun,
+            sceneApi,
+        });
+    }
+    if (unsupportedMutation)
+        return null;
+    return Array.from(updates, ([id, data]) => ({ id, data }));
+}
+/**
+ * 2D floor-plan move for a cabinet module — the parity twin of the 3D
+ * `movable.parentFrame` path. A module's `position` is run-local (rotated
+ * frame), so the generic overlay translate — which writes plan-space
+ * coordinates — teleports modules of any rotated / offset run and skips
+ * sibling edge-mating. Each tick: grid-snap the cursor in plan frame,
+ * convert through `planToLocal`, magnet against sibling modules, write the
+ * local position, and bump the run's layout revision so spans / countertop
+ * re-flow live (module position is not in the run's geometryKey). History is
+ * paused by the overlay; its snapshot-diff commit makes the drag one undo
+ * step covering both the module and the run metadata.
+ */
+export const cabinetModuleFloorplanMoveTarget = ({ node, nodes, }) => {
+    const moduleId = node.id;
+    const run = cabinetModuleParentFrame.resolveParent(node, nodes);
+    const originalLocal = [...node.position];
+    let lastLocal = originalLocal;
+    const session = {
+        affectedIds: run ? [moduleId, run.id] : [moduleId],
+        apply({ planPoint }) {
+            const snap = (value) => isGridSnapActive()
+                ? Math.round(value / useEditor.getState().gridSnapStep) *
+                    useEditor.getState().gridSnapStep
+                : value;
+            const planX = snap(planPoint[0]);
+            const planZ = snap(planPoint[1]);
+            // Orphan module (no cabinet run parent): plain plan-frame translate,
+            // same as the generic overlay would have done.
+            if (!run) {
+                lastLocal = [planX, originalLocal[1], planZ];
+                useLiveNodeOverrides.getState().set(moduleId, { position: lastLocal });
+                return;
+            }
+            let local = cabinetModuleParentFrame.planToLocal(run, planX, originalLocal[1], planZ, useScene.getState().nodes);
+            if (isMagneticSnapActive() || isGridSnapActive()) {
+                const snapFn = cabinetModuleParentFrame.magneticSnap;
+                if (snapFn) {
+                    const preSnapLocal = local;
+                    local = snapFn(node, run, local, useScene.getState().nodes);
+                    if (isAlignmentGuideActive()) {
+                        const guides = cabinetModuleParentFrame
+                            .magneticSnapMatches?.(node, run, preSnapLocal, local, useScene.getState().nodes)
+                            .map(alignmentGuideFromParentFrameMatch) ?? [];
+                        if (guides.length > 0)
+                            useAlignmentGuides.getState().set(guides);
+                        else
+                            useAlignmentGuides.getState().clear();
+                    }
+                }
+            }
+            // Wall attachment snap — 2D parity with the 3D move tool's
+            // `groupMoveSnap` pass: active in every snapping mode except Off.
+            if ((isGridSnapActive() || isMagneticSnapActive()) && run.parentId) {
+                const snapped = resolveCabinetModuleWallSnapLocal({
+                    candidateLocal: local,
+                    module: node,
+                    nodes: useScene.getState().nodes,
+                    parentLevelId: run.parentId,
+                    run,
+                });
+                if (snapped)
+                    local = snapped;
+            }
+            lastLocal = local;
+            useLiveNodeOverrides.getState().set(moduleId, { position: local });
+            useScene.getState().markDirty(run.id);
+        },
+        canCommit() {
+            const live = useScene.getState().nodes[moduleId];
+            if (live?.type !== 'cabinet-module')
+                return false;
+            return lastLocal[0] !== originalLocal[0] || lastLocal[2] !== originalLocal[2];
+        },
+        commit() {
+            const scene = useScene.getState();
+            useLiveNodeOverrides.getState().clear(moduleId);
+            useAlignmentGuides.getState().clear();
+            if (!run) {
+                scene.updateNodes([{ id: moduleId, data: { position: lastLocal } }]);
+                return;
+            }
+            const runId = run.id;
+            const updates = collectCabinetModuleMoveCommitUpdates({ lastLocal, moduleId, runId });
+            if (updates) {
+                scene.updateNodes(updates);
+                return;
+            }
+            scene.updateNodes([{ id: moduleId, data: { position: lastLocal } }]);
+            const liveRun = useScene.getState().nodes[runId];
+            if (liveRun?.type !== 'cabinet')
+                return;
+            const sceneApi = createSceneApi(useScene);
+            bumpCabinetRunLayoutRevision(sceneApi, liveRun);
+            // 2D ↔ 3D parity with `cabinetModuleParentFrame.onCommit`: re-anchor
+            // linked L-corner runs to the moved module's new edge.
+            const liveModule = useScene.getState().nodes[moduleId];
+            if (liveModule?.type === 'cabinet-module') {
+                syncCornerRunsFromSourceModule({
+                    module: liveModule,
+                    run: sceneApi.get(runId) ?? liveRun,
+                    sceneApi,
+                });
+            }
+        },
+    };
+    return session;
+};

package/dist/cabinet/floorplan-overrides.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, AnyNodeId, LiveTransformLike } from '@pascal-app/core';
+/**
+ * Cabinet floor-plan symbols resolve their full cabinet ancestry through
+ * `ctx.parent` / `ctx.resolve` (run -> module -> child run ...). During live
+ * drags only the directly moved cabinet nodes publish overrides, so we need to
+ * project those cabinet/cabinet-module patches into the context snapshot that
+ * the floor-plan builders read. That keeps every related cabinet symbol in
+ * lockstep while the drag is still in flight.
+ */
+export declare function cabinetFloorplanSiblingOverrides(args: {
+    nodeId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+    liveTransforms: Map<string, LiveTransformLike>;
+    liveOverrides: Map<string, Record<string, unknown>>;
+}): Record<AnyNodeId, AnyNode>;
+//# sourceMappingURL=floorplan-overrides.d.ts.map

package/dist/cabinet/floorplan-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/cabinet/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAE7E;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC9C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAmC7B"}

package/dist/cabinet/floorplan-overrides.js

@@ -0,0 +1,47 @@
+/**
+ * Cabinet floor-plan symbols resolve their full cabinet ancestry through
+ * `ctx.parent` / `ctx.resolve` (run -> module -> child run ...). During live
+ * drags only the directly moved cabinet nodes publish overrides, so we need to
+ * project those cabinet/cabinet-module patches into the context snapshot that
+ * the floor-plan builders read. That keeps every related cabinet symbol in
+ * lockstep while the drag is still in flight.
+ */
+export function cabinetFloorplanSiblingOverrides(args) {
+    const { nodes, liveOverrides, liveTransforms } = args;
+    if (liveOverrides.size === 0 && liveTransforms.size === 0)
+        return nodes;
+    let out = null;
+    const applyLiveTransform = (node, live) => {
+        if (!Array.isArray(node.position))
+            return node;
+        const rotation = node.rotation;
+        return {
+            ...node,
+            position: live.position,
+            rotation: typeof rotation === 'number'
+                ? live.rotation
+                : Array.isArray(rotation)
+                    ? [rotation[0] ?? 0, live.rotation, rotation[2] ?? 0]
+                    : rotation,
+        };
+    };
+    for (const [id, live] of liveTransforms) {
+        const existing = nodes[id];
+        if (existing?.type !== 'cabinet' && existing?.type !== 'cabinet-module')
+            continue;
+        if (!out)
+            out = { ...nodes };
+        out[id] = applyLiveTransform(out?.[id] ?? existing, live);
+    }
+    for (const [id, override] of liveOverrides) {
+        const existing = (out?.[id] ?? nodes[id]);
+        if (existing?.type !== 'cabinet' && existing?.type !== 'cabinet-module')
+            continue;
+        if (Object.keys(override).length === 0)
+            continue;
+        if (!out)
+            out = { ...nodes };
+        out[id] = { ...existing, ...override };
+    }
+    return out ?? nodes;
+}

package/dist/cabinet/floorplan.d.ts

@@ -0,0 +1,4 @@
+import type { CabinetModuleNode, CabinetNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+export declare function buildCabinetFloorplan(node: CabinetNode, ctx: GeometryContext): FloorplanGeometry | null;
+export declare function buildCabinetModuleFloorplan(node: CabinetModuleNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/cabinet/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAuBzB,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAsG1B;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAS1B"}

package/dist/cabinet/floorplan.js

@@ -0,0 +1,311 @@
+import { GAS_HOB_BURNER_RADIUS, gasHobBurners, inductionZones } from './geometry/cooktop';
+import { FAUCET_SETBACK, sinkBowls } from './geometry/sink';
+import { getRunSpanEnds, getRunSpans } from './run-layout';
+import { compartmentCooktopLayout, compartmentSinkLayout, isCooktopCompartmentType, isFridgeCompartmentType, isHoodCompartmentType, stackForCabinet, } from './stack';
+const BODY_FILL = '#ffffff';
+const BODY_STROKE = '#7c7468';
+const SYMBOL_STROKE = '#6f675b';
+const LABEL_FILL = '#6f675b';
+// Architectural convention: elements above the ~1.2m cut plane (wall
+// cabinets, hoods) draw with a dashed outline; floor-standing units solid.
+const ABOVE_CUT_DASH = '0.08 0.06';
+const SYMBOL_STROKE_WIDTH = 0.014;
+export function buildCabinetFloorplan(node, ctx) {
+    const modules = ctx.children.filter((child) => child.type === 'cabinet-module');
+    const showSelectedChrome = (ctx.viewState?.selected || ctx.viewState?.highlighted) ?? false;
+    const stroke = showSelectedChrome && ctx.viewState?.palette
+        ? ctx.viewState.palette.selectedStroke
+        : BODY_STROKE;
+    const spans = modules.length > 0
+        ? getRunSpans(modules, { runTier: node.runTier })
+        : [
+            {
+                minX: -node.width / 2,
+                maxX: node.width / 2,
+                centerX: 0,
+                centerZ: 0,
+                width: node.width,
+                depth: node.depth,
+                minZ: -node.depth / 2,
+                maxZ: node.depth / 2,
+                topY: node.carcassHeight,
+                hasCountertop: node.runTier === 'base' && node.withCountertop,
+            },
+        ];
+    const overhang = node.withCountertop ? node.countertopOverhang : 0;
+    const barEdge = node.barLedge?.edge;
+    const backOverhang = node.withCountertop && barEdge !== 'back' ? node.countertopBackOverhang : 0;
+    const spanEnds = getRunSpanEnds(node, ctx, spans);
+    const children = [];
+    for (const span of spans) {
+        const spanIndex = spans.indexOf(span);
+        const ends = spanEnds[spanIndex];
+        const hasSlab = node.withCountertop && span.hasCountertop;
+        // Countertop slab outline — the heavier line a kitchen plan reads first.
+        // Tall spans (no countertop) fall back to their carcass footprint. Side
+        // overhangs come from the shared span-end math so neighbor runs, L-corner
+        // legs, and side bars trim the plan outline exactly like the 3D slab.
+        const front = span.maxZ + (hasSlab ? overhang : 0);
+        const slabBack = span.minZ - (hasSlab ? backOverhang : 0);
+        // A finished decorative back panel adds real depth behind the carcass.
+        const back = Math.min(slabBack, node.withFinishedBack ? span.minZ - node.boardThickness : span.minZ);
+        const left = span.minX - (hasSlab ? ends.leftOverhang : 0);
+        const right = span.maxX + (hasSlab ? ends.rightOverhang : 0);
+        children.push({
+            kind: 'rect',
+            x: left,
+            y: back,
+            width: Math.max(0.01, right - left),
+            height: Math.max(0.01, front - back),
+            fill: node.runTier === 'wall' ? 'none' : BODY_FILL,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.03 : 0.022,
+            strokeDasharray: node.runTier === 'wall' ? ABOVE_CUT_DASH : undefined,
+            opacity: 0.95,
+        });
+        // Raised bar slab reads as its own counter band along the chosen edge
+        // (bar height sits below the ~1.2m cut plane, so it draws solid). Side
+        // bars apply only to the end span on that side.
+        const spanHasBar = node.barLedge &&
+            span.hasCountertop &&
+            (barEdge === 'back' ||
+                (barEdge === 'left' && spanIndex === 0) ||
+                (barEdge === 'right' && spanIndex === spans.length - 1));
+        if (node.barLedge && spanHasBar) {
+            const bar = barEdge === 'back'
+                ? {
+                    x: left,
+                    y: span.minZ - (node.withFinishedBack ? node.boardThickness : 0) - node.barLedge.depth,
+                    width: Math.max(0.01, right - left),
+                    height: node.barLedge.depth,
+                }
+                : {
+                    x: barEdge === 'left' ? span.minX - node.barLedge.depth : span.maxX,
+                    y: slabBack,
+                    width: node.barLedge.depth,
+                    height: Math.max(0.01, front - slabBack),
+                };
+            children.push({
+                kind: 'rect',
+                ...bar,
+                fill: BODY_FILL,
+                stroke,
+                strokeWidth: showSelectedChrome ? 0.03 : 0.022,
+                opacity: 0.95,
+            });
+        }
+    }
+    const world = resolveCabinetWorldPose(node, ctx);
+    return withWorldChrome(world.position, world.rotation, children, ctx, showSelectedChrome);
+}
+export function buildCabinetModuleFloorplan(node, ctx) {
+    const world = resolveCabinetWorldPose(node, ctx);
+    const parent = resolveCabinetParent(node.parentId, ctx);
+    return buildModuleSymbol(node, world.position, world.rotation, ctx, {
+        aboveCutPlane: parent?.type === 'cabinet-module'
+            ? true
+            : parent?.type === 'cabinet' && parent.runTier === 'wall',
+    });
+}
+function composeChild(parentPosition, parentRotation, childPosition, childRotation = 0) {
+    const cos = Math.cos(parentRotation);
+    const sin = Math.sin(parentRotation);
+    const [lx, ly, lz] = childPosition;
+    return {
+        position: [
+            parentPosition[0] + lx * cos + lz * sin,
+            parentPosition[1] + ly,
+            parentPosition[2] - lx * sin + lz * cos,
+        ],
+        rotation: parentRotation + childRotation,
+    };
+}
+function resolveCabinetParent(id, ctx) {
+    if (!id)
+        return null;
+    if (ctx.parent?.id === id &&
+        (ctx.parent.type === 'cabinet' || ctx.parent.type === 'cabinet-module')) {
+        return ctx.parent;
+    }
+    const resolved = ctx.resolve(id);
+    return resolved?.type === 'cabinet' || resolved?.type === 'cabinet-module' ? resolved : null;
+}
+function resolveCabinetWorldPose(node, ctx) {
+    const parent = resolveCabinetParent(node.parentId, ctx);
+    if (parent) {
+        const worldParent = resolveCabinetWorldPose(parent, ctx);
+        return composeChild(worldParent.position, worldParent.rotation, node.position, node.rotation);
+    }
+    return {
+        position: [...node.position],
+        rotation: node.rotation,
+    };
+}
+/**
+ * Wrap module-local symbol children in the plan transform and append
+ * world-space chrome (labels, selection handle). Plan rotate is `-rotation`
+ * so a Three.js Y-rotation (CCW top-down) turns the same way in the SVG plan.
+ */
+function withWorldChrome(position, rotation, localChildren, ctx, showSelectedChrome, worldChildren = []) {
+    const [cx, , cz] = position;
+    const children = [
+        {
+            kind: 'group',
+            transform: { translate: [cx, cz], rotate: -rotation },
+            children: localChildren,
+        },
+        ...worldChildren,
+    ];
+    if (showSelectedChrome) {
+        children.push({ kind: 'move-handle', point: [cx, cz] });
+    }
+    return { kind: 'group', children };
+}
+function buildModuleSymbol(node, position, rotation, ctx, opts) {
+    const showSelectedChrome = (ctx.viewState?.selected || ctx.viewState?.highlighted) ?? false;
+    const stroke = showSelectedChrome && ctx.viewState?.palette
+        ? ctx.viewState.palette.selectedStroke
+        : BODY_STROKE;
+    const stack = stackForCabinet(node);
+    const showCompartments = node.moduleKind !== 'corner-filler';
+    const hoodOnly = stack.length > 0 && stack.every((c) => isHoodCompartmentType(c.type));
+    const dashed = opts.aboveCutPlane || hoodOnly;
+    const hw = node.width / 2;
+    const hd = node.depth / 2;
+    const children = [
+        {
+            kind: 'rect',
+            x: -hw,
+            y: -hd,
+            width: node.width,
+            height: node.depth,
+            // Above-cut-plane units draw as a dashed open outline so the base
+            // cabinet underneath stays readable.
+            fill: dashed ? 'none' : BODY_FILL,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.03 : 0.018,
+            strokeDasharray: dashed ? ABOVE_CUT_DASH : undefined,
+            opacity: dashed ? 0.85 : 0.95,
+        },
+    ];
+    if (!dashed && showCompartments) {
+        // Cabinet front edge, inset from the countertop line the run draws.
+        children.push({
+            kind: 'line',
+            x1: -hw,
+            y1: hd,
+            x2: hw,
+            y2: hd,
+            stroke,
+            strokeWidth: 0.03,
+            opacity: 0.5,
+        });
+        for (const compartment of stack) {
+            children.push(...compartmentSymbol(compartment, node));
+        }
+    }
+    // Appliance labels live in world space with `upright` so they read
+    // horizontally regardless of run rotation and plan-view rotation.
+    const worldChildren = [];
+    const label = dashed || !showCompartments ? null : moduleLabel(stack);
+    if (label) {
+        worldChildren.push({
+            kind: 'text',
+            x: position[0],
+            y: position[2],
+            text: label,
+            fontSize: Math.min(0.16, node.width * 0.3),
+            fill: LABEL_FILL,
+            fontWeight: 600,
+            textAnchor: 'middle',
+            dominantBaseline: 'middle',
+            opacity: 0.9,
+            upright: true,
+        });
+    }
+    return withWorldChrome(position, rotation, children, ctx, showSelectedChrome, worldChildren);
+}
+/** Plan symbol for one compartment, in module-local metres (front = +y). */
+function compartmentSymbol(compartment, node) {
+    if (compartment.type === 'sink') {
+        const innerWidth = Math.max(0.01, node.width - 2 * node.boardThickness);
+        const bowls = sinkBowls(compartmentSinkLayout(compartment), innerWidth, node.depth);
+        const children = bowls.map((bowl) => ({
+            kind: 'rect',
+            x: bowl.centerX - bowl.width / 2,
+            y: -bowl.depth / 2,
+            width: bowl.width,
+            height: bowl.depth,
+            rx: 0.04,
+            ry: 0.04,
+            fill: 'none',
+            stroke: SYMBOL_STROKE,
+            strokeWidth: SYMBOL_STROKE_WIDTH,
+            opacity: 0.9,
+        }));
+        // Faucet dot behind the bowls (back = -y), aligned with the 3D faucet
+        // setback so the plan symbol stays centered in the rear strip.
+        children.push({
+            kind: 'circle',
+            cx: 0,
+            cy: -(bowls[0]?.depth ?? node.depth * 0.6) / 2 - FAUCET_SETBACK,
+            r: 0.02,
+            fill: 'none',
+            stroke: SYMBOL_STROKE,
+            strokeWidth: SYMBOL_STROKE_WIDTH,
+            opacity: 0.9,
+        });
+        return children;
+    }
+    if (isCooktopCompartmentType(compartment.type)) {
+        const layout = compartmentCooktopLayout(compartment, compartment.type);
+        const rings = compartment.type === 'cooktop-gas'
+            ? gasHobBurners(layout).map((burner) => ({
+                x: burner.x,
+                y: burner.z,
+                r: GAS_HOB_BURNER_RADIUS * burner.size,
+            }))
+            : inductionZones(layout).map((zone) => ({ x: zone.x, y: zone.z, r: zone.radius }));
+        return rings.flatMap((ring) => [
+            {
+                kind: 'circle',
+                cx: ring.x,
+                cy: ring.y,
+                r: ring.r,
+                fill: 'none',
+                stroke: SYMBOL_STROKE,
+                strokeWidth: SYMBOL_STROKE_WIDTH,
+                opacity: 0.9,
+            },
+            {
+                kind: 'circle',
+                cx: ring.x,
+                cy: ring.y,
+                r: ring.r * 0.45,
+                fill: 'none',
+                stroke: SYMBOL_STROKE,
+                strokeWidth: SYMBOL_STROKE_WIDTH * 0.8,
+                opacity: 0.7,
+            },
+        ]);
+    }
+    return [];
+}
+/** Standard plan abbreviation for the module's appliance content. */
+function moduleLabel(stack) {
+    if (stack.some((c) => isFridgeCompartmentType(c.type)))
+        return 'REF';
+    if (stack.some((c) => c.type === 'dishwasher'))
+        return 'DW';
+    const hasOven = stack.some((c) => c.type === 'oven');
+    const hasMicrowave = stack.some((c) => c.type === 'microwave');
+    if (hasOven && hasMicrowave)
+        return 'OV/MW';
+    if (hasOven)
+        return 'OV';
+    if (hasMicrowave)
+        return 'MW';
+    if (stack.some((c) => c.type === 'pull-out-pantry'))
+        return 'PAN';
+    return null;
+}

package/dist/cabinet/geometry/cooktop.d.ts

@@ -0,0 +1,20 @@
+import { Group } from 'three';
+import { type CabinetCompartment, type CabinetCooktopCompartmentType, type CooktopLayout } from '../stack';
+import { type CabinetGeometryNode } from './shared';
+export declare const GAS_HOB_BURNER_RADIUS = 0.052;
+export type CooktopBurnerSpec = {
+    x: number;
+    z: number;
+    size: number;
+};
+export type InductionZoneSpec = {
+    x: number;
+    z: number;
+    radius: number;
+    w?: number;
+    d?: number;
+};
+export declare function gasHobBurners(layout: CooktopLayout): CooktopBurnerSpec[];
+export declare function inductionZones(layout: CooktopLayout): InductionZoneSpec[];
+export declare function addCooktopCompartment(group: Group, node: CabinetGeometryNode, compartment: CabinetCompartment, type: CabinetCooktopCompartmentType, topY: number, index: number): void;
+//# sourceMappingURL=cooktop.d.ts.map

package/dist/cabinet/geometry/cooktop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cooktop.d.ts","sourceRoot":"","sources":["../../../src/cabinet/geometry/cooktop.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,EAMN,MAAM,OAAO,CAAA;AAOd,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,6BAA6B,EAClC,KAAK,aAAa,EAMnB,MAAM,UAAU,CAAA;AACjB,OAAO,EAGL,KAAK,mBAAmB,EAWzB,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAC1C,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AA+BtE,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAgBhG,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CASxE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,iBAAiB,EAAE,CAMzE;AA+SD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,mBAAmB,EACzB,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,6BAA6B,EACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,QAoJd"}