@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/slab/paint.js

@@ -1,17 +1,369 @@
-import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+import { area, containsPoint, distanceToBoundary, FOUNDATION_SLOT_DEFAULT, floorPlatePaintRefusal, floorStepKeysOf, floorStepOverrideFor, floorStepRoleCovers, intersection, parseFloorStepRole, parseMaterialRef, parseRoomFinishRole, roomFinishRole, runAsSingleSceneHistoryStep, SLAB_TOP_SLOT_DEFAULT, slabSlots, slotDefaultPaintMaterial, useScene, withFloorStepOverride, } from '@pascal-app/core';
+import { buildSlotPreviewMaterial, createSlotPaintCapability, declaredSlotLook, previewGeometrySlot, resolveSlotPaintMaterialRef, } from '../shared/slot-paint';
+import { swapPreviewMaterial } from '../shared/swap-preview-material';
+function zoneOf(zoneId) {
+    const node = useScene.getState().nodes[zoneId];
+    return node?.type === 'zone' ? node : null;
+}
 /**
- * Slab paint on the unified slot model. A slab exposes two faces — `surface`
- * (top) and `side` (walls + underside) — each its own mesh tagged with
- * `userData.slotId`, so the clicked face resolves to its slot; commit writes
- * `node.slots[slotId]` (a shared scene-material or `library:` ref) like the shelf.
+ * The footprint whose edge band a room's edge falls back to: the base plate of
+ * the level that overlaps `shape` most, as the renderer picks it.
  */
-export const slabPaint = createSlotPaintCapability({
+function edgeBandBase(shape) {
+    const overlap = (slab) => area(intersection({ outer: slab.polygon, holes: slab.holes }, { outer: shape.polygon, holes: shape.holes ?? [] }));
+    return Object.values(useScene.getState().nodes)
+        .filter((node) => node.type === 'slab' && node.plateRole === 'base' && node.parentId === shape.parentId)
+        .sort((a, b) => overlap(b) - overlap(a) || a.id.localeCompare(b.id))[0];
+}
+function sideRole(role) {
+    const step = parseFloorStepRole(role);
+    if (step)
+        return { ...step, field: 'floorStepFinish' };
+    const edge = /^edge:(.+)$/.exec(role);
+    return edge
+        ? { zoneId: edge[1], key: null, step: null, field: 'floorEdgeFinish' }
+        : null;
+}
+/** The rooms on `zone`'s level — where a doorway's step paint may be stored. */
+function levelZones(zone) {
+    return Object.values(useScene.getState().nodes).filter((node) => node.type === 'zone' && node.parentId === zone.parentId);
+}
+/** A doorway's own step paint, wherever it is stored. */
+function stepOverride(zone, key, step) {
+    return key ? floorStepOverrideFor(zone, key, step, levelZones(zone)) : undefined;
+}
+function readFinish(role) {
+    const side = sideRole(role);
+    if (side) {
+        const zone = zoneOf(side.zoneId);
+        if (side.field === 'floorStepFinish')
+            return ((zone && stepOverride(zone, side.key, side.step)?.finish) ??
+                zone?.floorStepFinish ??
+                zone?.floor?.finish ??
+                SLAB_TOP_SLOT_DEFAULT);
+        if (zone?.floorEdgeFinish)
+            return zone.floorEdgeFinish;
+        return zone ? edgeBandBase(zone)?.slots?.edge : undefined;
+    }
+    const parsed = parseRoomFinishRole(role);
+    if (!parsed)
+        return undefined;
+    const zone = zoneOf(parsed.zoneId);
+    if (!zone)
+        return undefined;
+    if (!parsed.regionId || parsed.regionId === ROOM_WIDE)
+        return zone.floor?.finish;
+    return zone.floor?.regions?.find((region) => region.id === parsed.regionId)?.finish;
+}
+/**
+ * Write a room finish in one history step, minting the shared scene material
+ * the same way `commitSlotPaint` does so a one-off colour is stored once.
+ */
+/** The region id a room-scope floor role carries: the whole room, every finish source. */
+export const ROOM_WIDE = '*';
+/** The zone a room-scope floor role (`room:<zoneId>/*`) names. */
+export function roomWideZone(role) {
+    const parsed = parseRoomFinishRole(role);
+    return parsed?.regionId === ROOM_WIDE ? parsed.zoneId : null;
+}
+/** A floor role naming the room's whole floor, not one painted part: `room:<zoneId>`. */
+function plainFloorZone(role) {
+    const parsed = parseRoomFinishRole(role);
+    return parsed && !parsed.regionId ? parsed.zoneId : null;
+}
+/** What a step shows with no paint of its own, its room's or its floor's. */
+const UNPAINTED_STEP = { materialPreset: SLAB_TOP_SLOT_DEFAULT };
+function lookMaterial(look) {
+    return look ? buildSlotPreviewMaterial(look.material, look.materialPreset) : null;
+}
+function swapPreviews(root, shown) {
+    const restores = [];
+    root.traverse((object) => {
+        const mesh = object;
+        const { paintRole, __fromGeometry } = mesh.userData;
+        if (!(mesh.isMesh && __fromGeometry === true && typeof paintRole === 'string'))
+            return;
+        const material = shown(paintRole);
+        if (material)
+            restores.push(swapPreviewMaterial(mesh, material));
+    });
+    return () => {
+        for (let index = restores.length - 1; index >= 0; index -= 1)
+            restores[index]?.();
+    };
+}
+/**
+ * A room floor's preview on one plate: the floor and the steps that follow it
+ * (no room step finish, no doorway paint). Painted, they take the paint;
+ * erased, the floor shows the plate's own top and its steps the unpainted step.
+ * The whole room (`wide`) also covers its painted parts; erased, it clears its
+ * edge too, and its steps whatever the room step finish.
+ */
+function previewRoomFloor(args, zoneId, wide) {
+    const zone = zoneOf(zoneId);
+    if (!zone)
+        return null;
+    const erasing = args.material === undefined && args.materialPreset === undefined;
+    const paint = erasing ? null : buildSlotPreviewMaterial(args.material, args.materialPreset);
+    const floorRole = roomFinishRole(zoneId);
+    const followingStep = (role) => {
+        const step = parseFloorStepRole(role);
+        return step?.zoneId === zoneId && !stepOverride(zone, step.key, step.step) ? step : null;
+    };
+    return swapPreviews(args.root, (role) => {
+        const step = followingStep(role);
+        const floorOrPart = role === floorRole || (wide && role.startsWith(`${floorRole}/`));
+        if (!erasing)
+            return floorOrPart || (step && !zone.floorStepFinish) ? paint : null;
+        if (floorOrPart)
+            return lookMaterial(plateSlotLook(args.node, 'surface'));
+        if (step && (wide || !zone.floorStepFinish))
+            return lookMaterial(UNPAINTED_STEP);
+        if (wide && zone.floorEdgeFinish && role === `edge:${zoneId}`)
+            return lookMaterial(footprintEdgeLook(args.node));
+        return null;
+    });
+}
+/**
+ * A footprint edge band's preview on one plate: the band itself on the
+ * footprint, and on any plate the room edges that carry the band (rooms with no
+ * edge finish of their own). Erased, each shows what it draws with no finish.
+ */
+function previewEdgeBand(args) {
+    const erasing = args.material === undefined && args.materialPreset === undefined;
+    const paint = erasing ? null : buildSlotPreviewMaterial(args.material, args.materialPreset);
+    return swapPreviews(args.root, (role) => {
+        const edge = /^edge:(.+)$/.exec(role);
+        if (role !== 'edge' && !(edge && !zoneOf(edge[1])?.floorEdgeFinish))
+            return null;
+        return paint ?? lookMaterial(bareSideLook(args.node, 'edge'));
+    });
+}
+function commitRoomFinish(role, material, materialPreset) {
+    const side = sideRole(role);
+    const parsed = side ? { zoneId: side.zoneId, regionId: null } : parseRoomFinishRole(role);
+    if (!parsed)
+        return;
+    const state = useScene.getState();
+    const resolution = resolveSlotPaintMaterialRef(state.materials, material, materialPreset);
+    if (!resolution)
+        return;
+    const { ref, newSceneMaterial } = resolution;
+    if (side?.field === 'floorStepFinish') {
+        commitStepFinish(side.zoneId, side.key, side.step, ref ?? undefined, newSceneMaterial);
+        return;
+    }
+    useScene.setState((current) => {
+        if (current.readOnly)
+            return current;
+        const zone = current.nodes[parsed.zoneId];
+        if (zone?.type !== 'zone')
+            return current;
+        const floor = { ...zone.floor };
+        if (parsed.regionId === ROOM_WIDE) {
+            // The room scope: painting gives the whole floor one finish, its painted
+            // parts included; erasing clears everything that makes it look painted —
+            // its finish, its painted parts, its steps and its edge.
+            if (ref)
+                floor.finish = ref;
+            else
+                delete floor.finish;
+            delete floor.regions;
+        }
+        else if (parsed.regionId) {
+            const regions = floor.regions ?? [];
+            const index = regions.findIndex((region) => region.id === parsed.regionId);
+            if (index < 0)
+                return current;
+            // A region with no finish would fall through to the room finish, which is
+            // what the eraser should do — but the schema requires one, so an erased
+            // region drops out of the list instead.
+            floor.regions = ref
+                ? regions.map((region, at) => (at === index ? { ...region, finish: ref } : region))
+                : regions.filter((_, at) => at !== index);
+        }
+        else if (ref) {
+            floor.finish = ref;
+        }
+        else {
+            delete floor.finish;
+        }
+        const next = (side ? { ...zone, [side.field]: ref ?? undefined } : { ...zone, floor });
+        if (parsed.regionId === ROOM_WIDE && !ref) {
+            delete next.floorStepFinish;
+            delete next.floorEdgeFinish;
+        }
+        return {
+            ...(newSceneMaterial
+                ? { materials: { ...current.materials, [newSceneMaterial.id]: newSceneMaterial } }
+                : {}),
+            nodes: { ...current.nodes, [parsed.zoneId]: next },
+        };
+    });
+    useScene.getState().markDirty(parsed.zoneId);
+}
+/**
+ * Paint (`ref`) or erase a room's steps in one history step. A doorway role
+ * writes that doorway's override (see `withFloorStepOverride`); the room scope
+ * sets the room's step finish and drops the doorway paint of every step the
+ * room currently has, so all of them show it. Overrides of steps the room does
+ * not have are someone else's and stay.
+ */
+function commitStepFinish(zoneId, key, step, ref, newSceneMaterial) {
+    const changed = [];
+    useScene.setState((current) => {
+        if (current.readOnly)
+            return current;
+        const owner = current.nodes[zoneId];
+        if (owner?.type !== 'zone')
+            return current;
+        const zones = new Map(Object.values(current.nodes)
+            .filter((node) => node.type === 'zone' && node.parentId === owner.parentId)
+            .map((zone) => [zone.id, zone]));
+        const apply = (doorway, finish) => {
+            for (const zone of withFloorStepOverride(zones.get(zoneId), doorway, key ? step : null, finish, [...zones.values()]))
+                zones.set(zone.id, zone);
+        };
+        if (key)
+            apply(key, ref);
+        else {
+            for (const doorway of floorStepKeysOf(current.nodes, owner.parentId ?? '', zoneId))
+                apply(doorway, undefined);
+            const next = { ...zones.get(zoneId) };
+            if (ref)
+                next.floorStepFinish = ref;
+            else
+                delete next.floorStepFinish;
+            zones.set(zoneId, next);
+        }
+        const nodes = { ...current.nodes };
+        for (const [id, zone] of zones)
+            if (zone !== current.nodes[id]) {
+                nodes[id] = zone;
+                changed.push(id);
+            }
+        if (!changed.length && !newSceneMaterial)
+            return current;
+        return {
+            ...(newSceneMaterial
+                ? { materials: { ...current.materials, [newSceneMaterial.id]: newSceneMaterial } }
+                : {}),
+            nodes,
+        };
+    });
+    for (const id of changed)
+        useScene.getState().markDirty(id);
+}
+function baseSurfaceRoom(node, point) {
+    if (node.type !== 'slab' || node.plateRole !== 'base')
+        return null;
+    const zones = (node.zoneIds ?? [])
+        .map(zoneOf)
+        .filter((zone) => !!zone && zone.hasFloor !== false);
+    if (point)
+        zones.sort((a, b) => {
+            const distance = (zone) => {
+                const polygon = [{ outer: zone.polygon, holes: zone.holes }];
+                const p = [point[0], point[2]];
+                return containsPoint(polygon, p) ? 0 : distanceToBoundary(polygon, p);
+            };
+            return distance(a) - distance(b) || a.id.localeCompare(b.id);
+        });
+    return zones[0] ? `room:${zones[0].id}` : null;
+}
+/** A finish ref or inline legacy material, as a look. */
+function finishLook(finish) {
+    if (finish === undefined)
+        return null;
+    return typeof finish === 'string'
+        ? { materialPreset: finish }
+        : { material: finish };
+}
+/** A plate slot as drawn: its value, else its legacy finish, else its declared default. */
+function plateSlotLook(node, slot) {
+    return (base.getEffectiveMaterial?.({
+        node,
+        role: slot,
+        nodes: useScene.getState().nodes,
+        materials: useScene.getState().materials,
+    }) ?? slotDefaultPaintMaterial(slabSlots().find((entry) => entry.slotId === slot)?.default));
+}
+/**
+ * A plate side face with no finish of its own: the pre-split `side` slot, else
+ * the declared default — the renderer's fallback for edge, riser and underside.
+ */
+function bareSideLook(node, slot) {
+    return (finishLook(node.slots?.side) ??
+        slotDefaultPaintMaterial(slabSlots().find((entry) => entry.slotId === slot)?.default));
+}
+/** A room edge with no edge finish: its footprint's band, else the bare face. */
+function footprintEdgeLook(node) {
+    const plate = node;
+    return finishLook(edgeBandBase(plate)?.slots?.edge) ?? bareSideLook(node, 'edge');
+}
+/**
+ * What a floor surface shows once erased: a region falls to its room's floor
+ * finish, a room's floor finish to the plate's own top, the room's steps to its
+ * floor, its edge to the footprint's edge band, a plate's side faces to their
+ * bare look, a slot to its declared default.
+ */
+export function erasedSlabLook({ node, role }) {
+    if (role === 'foundation')
+        return declaredSlotLook(node, role);
+    if (node.boundary === 'auto' && (role === 'riser' || role === 'underside'))
+        return bareSideLook(node, role);
+    const side = sideRole(role);
+    if (side) {
+        const zone = zoneOf(side.zoneId);
+        // A doorway falls back to the room's steps, the room's steps to its floor,
+        // then to the unpainted step; a room's edge to its footprint's band.
+        return side.field === 'floorStepFinish'
+            ? ((side.key ? finishLook(zone?.floorStepFinish) : null) ??
+                finishLook(zone?.floor?.finish) ??
+                UNPAINTED_STEP)
+            : footprintEdgeLook(node);
+    }
+    const parsed = parseRoomFinishRole(role);
+    if (!parsed)
+        return declaredSlotLook(node, role);
+    const floor = parsed.regionId ? zoneOf(parsed.zoneId)?.floor?.finish : undefined;
+    return finishLook(floor) ?? plateSlotLook(node, 'surface');
+}
+const base = createSlotPaintCapability({
     roomScope: true,
-    resolveRole: ({ hitObject }) => {
+    // A floor, the whole room and a footprint's edge band preview their
+    // followers too, erased included, so they build their own erased look.
+    erasedLook: (args) => roomWideZone(args.role) ||
+        (args.node.boundary === 'auto' &&
+            (plainFloorZone(args.role) || args.role === 'edge'))
+        ? null
+        : erasedSlabLook(args),
+    resolveRole: ({ node, hitObject, localPosition }) => {
+        const paintRole = hitObject?.userData.paintRole;
+        if (typeof paintRole === 'string')
+            return paintRole === 'surface'
+                ? (baseSurfaceRoom(node, localPosition) ?? paintRole)
+                : paintRole;
         const slotId = hitObject?.userData?.slotId;
-        return slotId === 'side' ? 'side' : 'surface';
+        if (typeof slotId !== 'string')
+            return null;
+        return slotId === 'surface' ? (baseSurfaceRoom(node, localPosition) ?? slotId) : slotId;
+    },
+    applyPreview: (args) => {
+        const zoneId = roomWideZone(args.role);
+        if (zoneId)
+            return previewRoomFloor(args, zoneId, true);
+        if (args.node.boundary === 'auto') {
+            const floor = plainFloorZone(args.role);
+            if (floor)
+                return previewRoomFloor(args, floor, false);
+            if (args.role === 'edge')
+                return previewEdgeBand(args);
+        }
+        return parseFloorStepRole(args.role)
+            ? previewGeometrySlot(args, (meshRole) => floorStepRoleCovers(args.role, meshRole))
+            : previewGeometrySlot(args);
     },
-    applyPreview: previewGeometrySlot,
     // Legacy inline material applied to the whole slab → maps onto the top only;
     // the side picker shows its own default.
     legacyEffective: (node, role) => {
@@ -24,3 +376,100 @@ export const slabPaint = createSlotPaintCapability({
         return null;
     },
 });
+export const slabPaint = {
+    ...base,
+    // "Steps · Kitchen": the room a floor finish belongs to, by name.
+    roleLabel: (_node, role) => {
+        if (role === 'foundation')
+            return 'Foundation';
+        const side = sideRole(role);
+        const zoneId = side?.zoneId ?? parseRoomFinishRole(role)?.zoneId;
+        if (!zoneId)
+            return null;
+        const part = side ? (side.field === 'floorStepFinish' ? 'Steps' : 'Floor edge') : 'Floor';
+        const room = zoneOf(zoneId)?.name?.trim() || 'Room';
+        if (!side?.key)
+            return `${part} · ${room}`;
+        const through = useScene.getState().nodes[side.key];
+        const label = through?.type === 'zone'
+            ? through.name?.trim() || 'Room'
+            : through?.name?.trim() || 'Doorway';
+        return `${part} · ${room} · ${label}`;
+    },
+    buildPatch: (args) => args.role === 'foundation' || sideRole(args.role) || parseRoomFinishRole(args.role)
+        ? {}
+        : base.buildPatch(args),
+    commit: (args) => {
+        if (args.role === 'surface' && args.node.type === 'slab' && args.node.plateRole === 'base') {
+            const role = baseSurfaceRoom(args.node);
+            if (!role)
+                return floorPlatePaintRefusal(useScene.getState().nodes, args.node, args.role) ?? undefined;
+            commitRoomFinish(role, args.material, args.materialPreset);
+            return;
+        }
+        if (args.role === 'foundation') {
+            const state = useScene.getState();
+            const plate = state.nodes[args.node.id];
+            if (plate?.type !== 'slab' || plate.plateRole !== 'base' || state.readOnly)
+                return;
+            const resolution = resolveSlotPaintMaterialRef(state.materials, args.material, args.materialPreset);
+            if (!resolution)
+                return;
+            const { ref, newSceneMaterial } = resolution;
+            runAsSingleSceneHistoryStep(useScene, () => {
+                if (newSceneMaterial)
+                    useScene.getState().addSceneMaterial(newSceneMaterial);
+                useScene.getState().updateNode(plate.id, {
+                    foundation: {
+                        ...plate.foundation,
+                        type: plate.foundation?.type ?? 'none',
+                        material: ref ?? undefined,
+                    },
+                });
+            });
+            return;
+        }
+        if (sideRole(args.role) || parseRoomFinishRole(args.role)) {
+            commitRoomFinish(args.role, args.material, args.materialPreset);
+            return;
+        }
+        base.commit?.(args);
+    },
+    getEffectiveMaterial: (args) => {
+        if (!(args.role === 'foundation' || sideRole(args.role) || parseRoomFinishRole(args.role)))
+            return base.getEffectiveMaterial?.(args) ?? null;
+        const finish = args.role === 'foundation'
+            ? (args.node.foundation?.material ?? FOUNDATION_SLOT_DEFAULT)
+            : readFinish(args.role);
+        if (finish === undefined) {
+            // Unpainted, a room's floor shows the plate's own top and its edge the
+            // plate's edge band — each the slot's value, else its declared default.
+            const slot = !args.rendered
+                ? null
+                : parseRoomFinishRole(args.role)
+                    ? 'surface'
+                    : sideRole(args.role)?.field === 'floorEdgeFinish'
+                        ? 'edge'
+                        : null;
+            if (!slot)
+                return null;
+            const effective = base.getEffectiveMaterial?.({ ...args, role: slot }) ??
+                slotDefaultPaintMaterial(slabSlots().find((entry) => entry.slotId === slot)?.default);
+            return effective
+                ? { material: effective.material, materialPreset: effective.materialPreset }
+                : null;
+        }
+        if (typeof finish !== 'string') {
+            return { material: finish, materialPreset: undefined };
+        }
+        const parsed = parseMaterialRef(finish);
+        if (parsed?.kind === 'library')
+            return { material: undefined, materialPreset: finish };
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = useScene.getState().materials[parsed.id];
+            if (sceneMaterial)
+                return { material: sceneMaterial.material, materialPreset: undefined };
+        }
+        return null;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AA+BA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCAgaxB;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCA0cxB;AAED,eAAe,SAAS,CAAA"}

package/dist/slab/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { MIN_SLAB_THICKNESS, useScene } from '@pascal-app/core';
-import { ActionButton, ActionGroup, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { isDerivedNode, MIN_SLAB_THICKNESS, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, FloorFoundationPanel, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, ShapeChoice, SliderControl, startOpeningDraft, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Edit, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useRef } from 'react';
@@ -24,9 +24,14 @@ export function SlabPanel() {
     const editingHole = useEditingHole();
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
-    // See "Panel slider-drag fix recipe" in plans/editor-node-registry.md.
-    // Stable handler refs across re-renders so slider drags don't trigger
-    // a Maximum update depth cascade on the panel's SliderControls.
+    useEffect(() => {
+        if (!node?.plateRole || node.plateRole === 'base' || !node.parentId || !node.zoneIds?.[0])
+            return;
+        useViewer.getState().setSelection({ selectedIds: [] });
+        useEditor.getState().selectRoom({ levelId: node.parentId, zoneId: node.zoneIds[0] });
+    }, [node]);
+    // Stable handler refs so slider drags don't trigger a Maximum update depth
+    // cascade; see "Custom panels" in wiki/architecture/node-definitions.md.
     const nodeRef = useRef(node);
     nodeRef.current = node;
     const handleUpdate = useCallback((updates) => {
@@ -171,6 +176,11 @@ export function SlabPanel() {
     }, [node, setMovingNode, setSelection]);
     if (!(node && node.type === 'slab' && selectedId))
         return null;
+    if (node.plateRole === 'base')
+        return _jsx(FloorFoundationPanel, { node: node, onClose: handleClose });
+    const derived = isDerivedNode(node);
+    const room = useEditor.getState().room;
+    const openingZoneId = room && node.zoneIds?.includes(room.zoneId) ? room.zoneId : node.zoneIds?.[0];
     const calculateArea = (polygon) => {
         if (polygon.length < 3)
             return 0;
@@ -210,13 +220,22 @@ export function SlabPanel() {
                             const holeArea = calculateArea(hole);
                             const isEditing = editingHole?.nodeId === selectedId && editingHole?.holeIndex === index;
                             const source = node.holeMetadata?.[index]?.source ?? 'manual';
-                            const isAutoHole = source !== 'manual';
-                            const autoLabel = source === 'elevator' ? 'Auto elevator cutout' : 'Auto stair cutout';
+                            // A derived plate's holes are owned by its rooms and openings: an
+                            // opening's hole opens that opening, the rest are read-only.
+                            const openingId = derived ? node.holeMetadata?.[index]?.openingId : undefined;
+                            const isAutoHole = source !== 'manual' || derived;
+                            const autoLabel = source === 'elevator'
+                                ? 'Auto elevator cutout'
+                                : source === 'stair'
+                                    ? 'Auto stair cutout'
+                                    : source === 'floor-opening'
+                                        ? 'Opening'
+                                        : 'Room cutout';
                             return (_jsxs("div", { className: `flex items-center justify-between rounded-lg border p-2 transition-colors ${isEditing
                                     ? 'border-primary/50 bg-primary/10'
                                     : 'border-transparent hover:bg-accent/30'}`, children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("p", { className: `font-medium text-xs ${isEditing ? 'text-primary' : 'text-white'}`, children: ["Hole ", index + 1, " ", isEditing && '(Editing)'] }), _jsxs("p", { className: "text-[10px] text-muted-foreground", children: [holeArea.toFixed(2), " m\u00B2 \u00B7 ", hole.length, " pts \u00B7", ' ', isAutoHole ? autoLabel : 'Manual'] })] }), _jsx("div", { className: "flex items-center gap-1", children: isEditing ? (_jsx(ActionButton, { className: "h-7 bg-primary text-primary-foreground hover:bg-primary/90", label: "Done", onClick: () => useInteractionScope
                                                 .getState()
-                                                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole') })) : isAutoHole ? (_jsx("div", { className: "rounded-md bg-[#2C2C2E] px-2 py-1 text-[10px] text-muted-foreground", children: "Auto" })) : (_jsxs(_Fragment, { children: [_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => handleEditHole(index), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) }), _jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-red-500/10 text-red-400 hover:bg-red-500/20 hover:text-red-300", onClick: () => handleDeleteHole(index), type: "button", children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })) })] }, index));
-                        }) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: "No holes" })), _jsx("div", { className: "px-1 pt-1 pb-1", children: _jsx(ActionButton, { className: "w-full", disabled: editingHole?.nodeId === selectedId, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Hole", onClick: handleAddHole }) })] }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }) })] }));
+                                                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole') })) : openingId ? (_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground", "data-slab-hole-opening": openingId, onClick: () => setSelection({ selectedIds: [openingId] }), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) })) : isAutoHole ? (_jsx("div", { className: "rounded-md bg-[#2C2C2E] px-2 py-1 text-[10px] text-muted-foreground", children: "Auto" })) : (_jsxs(_Fragment, { children: [_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => handleEditHole(index), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) }), _jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-red-500/10 text-red-400 hover:bg-red-500/20 hover:text-red-300", onClick: () => handleDeleteHole(index), type: "button", children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })) })] }, index));
+                        }) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: "No holes" })), _jsx("div", { className: "px-1 pt-1 pb-1", children: derived ? (_jsx(ShapeChoice, { className: "px-1 text-muted-foreground text-xs", disabled: !openingZoneId, label: node.support === 'open' ? 'Cut hatch' : 'Cut opening', onPick: (shape) => openingZoneId && startOpeningDraft(openingZoneId, 'floor', shape) })) : (_jsx(ActionButton, { className: "w-full", disabled: editingHole?.nodeId === selectedId, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Hole", onClick: handleAddHole })) })] }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }) })] }));
 }
 export default SlabPanel;

package/dist/slab/placement-ownership.d.ts

@@ -1,3 +1,4 @@
+import type { VisibleScene } from '@pascal-app/editor';
 export type SlabCompletionTrigger = 'grid' | 'keyboard';
-export declare function shouldRegistryCommitSlab(viewMode: '2d' | '3d' | 'split', trigger: SlabCompletionTrigger): boolean;
+export declare function shouldRegistryCommitSlab(scene: VisibleScene | null, trigger: SlabCompletionTrigger): boolean;
 //# sourceMappingURL=placement-ownership.d.ts.map

package/dist/slab/placement-ownership.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placement-ownership.d.ts","sourceRoot":"","sources":["../../src/slab/placement-ownership.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,UAAU,CAAA;AAEvD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,EAC/B,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAET"}
+{"version":3,"file":"placement-ownership.d.ts","sourceRoot":"","sources":["../../src/slab/placement-ownership.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,UAAU,CAAA;AAEvD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAET"}

package/dist/slab/placement-ownership.js

@@ -1,3 +1,3 @@
-export function shouldRegistryCommitSlab(viewMode, trigger) {
-    return trigger === 'keyboard' || viewMode !== '2d';
+export function shouldRegistryCommitSlab(scene, trigger) {
+    return trigger === 'keyboard' || scene !== '2d';
 }

package/dist/slab/surface-split.d.ts

@@ -0,0 +1,24 @@
+import { type PlateSurfacePartition, type SlabNode } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+export type SplitBucket = {
+    role: string;
+    geometry: BufferGeometry;
+};
+/**
+ * Split a slab buffer by face orientation only — the pre-plate behaviour, kept
+ * verbatim for manual slabs so their two meshes and their paint slots never
+ * change.
+ */
+export declare function splitSlabFacesByFacing(geometry: BufferGeometry): {
+    top: BufferGeometry;
+    side: BufferGeometry;
+};
+/**
+ * Split a plate buffer into one bucket per rendered role: a top bucket per
+ * partition cell, `edge` / `riser` per exposure run, and `underside`. Buckets
+ * come back in a stable order (cells in partition order, then the sides) so the
+ * mesh order of a plate is the same on every rebuild.
+ */
+export declare function splitPlateFaces(geometry: BufferGeometry, partition: PlateSurfacePartition, slab: Pick<SlabNode, 'elevation' | 'thickness' | 'polygon' | 'holes'>): SplitBucket[];
+export declare function clipPlateTerrainFill(geometry: BufferGeometry, partition: PlateSurfacePartition): BufferGeometry;
+//# sourceMappingURL=surface-split.d.ts.map

package/dist/slab/surface-split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-split.d.ts","sourceRoot":"","sources":["../../src/slab/surface-split.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,qBAAqB,EAG1B,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,cAAc,EAA+C,MAAM,OAAO,CAAA;AAqBnF,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAA;CAAE,CAAA;AAgNpE;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,cAAc,GAAG;IAChE,GAAG,EAAE,cAAc,CAAA;IACnB,IAAI,EAAE,cAAc,CAAA;CACrB,CAQA;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,GACpE,WAAW,EAAE,CAmJf;AA4BD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,qBAAqB,GAC/B,cAAc,CA0BhB"}