@pascal-app/nodes 0.1.1

package/dist/slab/floorplan.js

@@ -0,0 +1,144 @@
+import { getRenderableSlabPolygon, slabPolygonContextFromGeometry, } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for slab. Renders the slab polygon as a
+ * filled path with holes cut out; when selected, overlays themed
+ * chrome (accent stroke, hatch fill) plus the full boundary editor:
+ *
+ *   - Vertex handles on every polygon corner (orange dots).
+ *   - Midpoint `+` handles between vertices to insert a new vertex.
+ *   - Edge handles along each edge so the user can drag the whole
+ *     edge perpendicular.
+ *   - Same three handle sets for every hole in `node.holes`, with the
+ *     `holeIndex` carried in each handle's payload.
+ *
+ * Uses `getRenderableSlabPolygon` for the visible fill (per-edge render
+ * offsets against level walls + sibling slabs), but vertex / edge /
+ * midpoint handles live on the **raw** `node.polygon` — matches the
+ * legacy slab boundary editor which always operates on raw data.
+ */
+export function buildSlabFloorplan(node, ctx) {
+    const polygon = node.polygon;
+    if (!polygon || polygon.length < 3)
+        return null;
+    const visualPolygon = getRenderableSlabPolygon(node, slabPolygonContextFromGeometry(ctx));
+    if (!visualPolygon || visualPolygon.length < 3)
+        return null;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const outer = visualPolygon.map(([x, z]) => [x, z]);
+    const ring = (points) => {
+        const [first, ...rest] = points;
+        if (!first)
+            return '';
+        return [`M ${first[0]} ${first[1]}`, ...rest.map(([x, y]) => `L ${x} ${y}`), 'Z'].join(' ');
+    };
+    const segments = [ring(outer)];
+    const holes = node.holes ?? [];
+    for (const hole of holes) {
+        if (hole.length < 3)
+            continue;
+        const holePts = hole.map(([x, z]) => [x, z]);
+        segments.push(ring(holePts));
+    }
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#475569';
+    const fill = showSelectedChrome ? '#ffffff' : '#cbd5e1';
+    // Slab body. Uses `fillOpacity` / `strokeOpacity` independently so the
+    // outline stays crisp while the fill stays translucent — zones under
+    // the slab read through, and on the selected state the hatch overlay
+    // (`{ kind: 'hatch' }` below) carries the visual weight without the
+    // background going opaque-white.
+    const children = [
+        {
+            kind: 'path',
+            d: segments.join(' '),
+            fill,
+            fillOpacity: showSelectedChrome ? 0.45 : 0.6,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.04 : 0.03,
+            strokeOpacity: showSelectedChrome ? 0.96 : 0.85,
+        },
+    ];
+    // Hatch overlay on selected — same `<defs>` pattern as the wall.
+    if (isSelected && palette) {
+        children.push({
+            kind: 'hatch',
+            points: outer,
+            color: palette.selectedHatch,
+            opacity: 0.7,
+        });
+    }
+    // Boundary editor — visible only when the slab is the active selection.
+    if (isSelected) {
+        // Handles operate on the STORED polygon while the fill shows the
+        // band-healed render polygon; when the two diverge (edges projected
+        // onto wall faces / interior centerline seams), a dashed skeleton of the
+        // stored boundary shows what the handles actually grab.
+        const rawDiffersFromVisual = polygon.length !== visualPolygon.length ||
+            polygon.some((point, index) => {
+                const visual = visualPolygon[index];
+                return Math.abs(point[0] - visual[0]) > 0.005 || Math.abs(point[1] - visual[1]) > 0.005;
+            });
+        if (rawDiffersFromVisual) {
+            children.push({
+                kind: 'path',
+                d: ring(polygon.map(([x, z]) => [x, z])),
+                fill: 'none',
+                stroke: palette ? palette.selectedStroke : '#475569',
+                strokeWidth: 0.015,
+                strokeOpacity: 0.55,
+                strokeDasharray: '0.08 0.06',
+            });
+        }
+        appendRingEditor(children, polygon, undefined);
+        holes.forEach((hole, holeIndex) => {
+            if (hole.length >= 3)
+                appendRingEditor(children, hole, holeIndex);
+        });
+    }
+    return { kind: 'group', children };
+}
+/**
+ * Push vertex / midpoint / edge handles for a single ring (boundary or
+ * hole). `holeIndex === undefined` targets `node.polygon`; otherwise
+ * `node.holes[holeIndex]`. Emits in this order so the hit-test
+ * priority is sensible: edges first (largest hit area, lowest z),
+ * then midpoints, then vertices on top.
+ */
+function appendRingEditor(children, ring, holeIndex) {
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        children.push({
+            kind: 'edge-handle',
+            x1: a[0],
+            y1: a[1],
+            x2: b[0],
+            y2: b[1],
+            affordance: 'move-edge',
+            payload: { holeIndex, edgeIndex: i },
+        });
+    }
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        children.push({
+            kind: 'midpoint-handle',
+            point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+            affordance: 'add-vertex',
+            payload: { holeIndex, edgeIndex: i },
+        });
+    }
+    for (let i = 0; i < ring.length; i++) {
+        const [x, z] = ring[i];
+        children.push({
+            kind: 'endpoint-handle',
+            point: [x, z],
+            state: 'idle',
+            affordance: 'move-vertex',
+            payload: { holeIndex, vertexIndex: i },
+        });
+    }
+}

package/dist/slab/geometry.d.ts

@@ -0,0 +1,5 @@
+import { type GeometryContext, type SlabNode } from '@pascal-app/core';
+import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+export declare function buildSlabGeometry(node: SlabNode, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/slab/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAqJd,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA8BP"}

package/dist/slab/geometry.js

@@ -0,0 +1,133 @@
+import { getMaterialPresetByRef, slabPolygonContextFromGeometry, } from '@pascal-app/core';
+import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateSlabGeometry, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, Vector3, } from 'three';
+import { SLAB_SIDE_SLOT_DEFAULT, SLAB_TOP_SLOT_DEFAULT } from './slots';
+const slabMaterialCache = new Map();
+function getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, sceneMaterials) {
+    // Textures-off mode takes the themed 'floor' role colour for every face — the
+    // guaranteed escape hatch, independent of any slot override. FrontSide —
+    // DoubleSide on the role material's NodeMaterial poisons the MRT scene pass
+    // (see `materials.ts` line 77 / glazing fix 9400f1c5). Slab side faces still
+    // render correctly because `generateSlabGeometry` emits outward-facing normals.
+    if (!textures) {
+        return createSurfaceRoleMaterial('floor', colorPreset, FrontSide, sceneTheme);
+    }
+    // Unified slot override — shared scene material or catalog `library:` finish.
+    const slotRef = node.slots?.[slotId];
+    if (slotRef) {
+        const resolved = resolveMaterialRef(slotRef, sceneMaterials, shading);
+        if (resolved)
+            return resolved;
+    }
+    // Legacy inline material / preset (pre-slot-model scenes) applied to the whole
+    // slab — map it onto the top face only; sides take their own default.
+    if (slotId === 'surface' && (node.materialPreset || node.material)) {
+        return getLegacySlabMaterial(node, shading);
+    }
+    // Declared slot default — a catalog `library:` finish or a flat colour.
+    const slotDefault = slotId === 'side' ? SLAB_SIDE_SLOT_DEFAULT : SLAB_TOP_SLOT_DEFAULT;
+    return resolveSlotDefaultMaterial(slotDefault, shading, 0.8);
+}
+// Split the merged slab buffer into top-facing (floor) and everything-else
+// (vertical walls + underside) sub-geometries by per-triangle face normal, so
+// the two paintable slots get distinct materials + raycast tags. De-indexes
+// into per-face triangles (slabs are flat-shaded, so no shared-vertex seams).
+function splitSlabFacesByFacing(geometry) {
+    const position = geometry.getAttribute('position');
+    const uv = geometry.getAttribute('uv');
+    const index = geometry.getIndex();
+    const triangleCount = index ? index.count / 3 : position.count / 3;
+    const top = { pos: [], uv: [] };
+    const side = { pos: [], uv: [] };
+    const a = new Vector3();
+    const b = new Vector3();
+    const c = new Vector3();
+    const ab = new Vector3();
+    const ac = new Vector3();
+    const normal = new Vector3();
+    for (let t = 0; t < triangleCount; t += 1) {
+        const i0 = index ? index.getX(t * 3) : t * 3;
+        const i1 = index ? index.getX(t * 3 + 1) : t * 3 + 1;
+        const i2 = index ? index.getX(t * 3 + 2) : t * 3 + 2;
+        a.fromBufferAttribute(position, i0);
+        b.fromBufferAttribute(position, i1);
+        c.fromBufferAttribute(position, i2);
+        ab.subVectors(b, a);
+        ac.subVectors(c, a);
+        normal.crossVectors(ab, ac);
+        const lengthSq = normal.lengthSq();
+        const isTop = lengthSq > 1e-12 && normal.y / Math.sqrt(lengthSq) > 0.5;
+        const target = isTop ? top : side;
+        for (const i of [i0, i1, i2]) {
+            target.pos.push(position.getX(i), position.getY(i), position.getZ(i));
+            if (uv)
+                target.uv.push(uv.getX(i), uv.getY(i));
+        }
+    }
+    const build = (data) => {
+        const geo = new BufferGeometry();
+        geo.setAttribute('position', new Float32BufferAttribute(data.pos, 3));
+        if (data.uv.length > 0)
+            geo.setAttribute('uv', new Float32BufferAttribute(data.uv, 2));
+        geo.computeVertexNormals();
+        return geo;
+    };
+    return { top: build(top), side: build(side) };
+}
+function getLegacySlabMaterial(node, shading) {
+    // Cached by `{material, materialPreset}` signature so slabs sharing settings
+    // share the GPU resource; cached entry mutation (preset apply) is preserved
+    // so async texture loads still update the rendered material after re-mount.
+    const cacheKey = JSON.stringify({
+        shading,
+        material: node.material ?? null,
+        materialPreset: node.materialPreset ?? null,
+    });
+    const cached = slabMaterialCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const preset = getMaterialPresetByRef(node.materialPreset);
+    const material = preset
+        ? createDefaultMaterial('#ffffff', 0.5, shading)
+        : node.material
+            ? createMaterial(node.material, shading).clone()
+            : createDefaultMaterial('#e5e5e5', 0.8, shading);
+    if (preset) {
+        applyMaterialPresetToMaterials(material, preset);
+    }
+    const slabMaterial = material;
+    slabMaterial.transparent = false;
+    slabMaterial.opacity = 1;
+    slabMaterial.alphaMap = null;
+    // FrontSide — user-supplied materials may be NodeMaterials, and DoubleSide
+    // on any NodeMaterial in the MRT scene pass poisons the render context
+    // (see `materials.ts` line 77 / glazing fix 9400f1c5).
+    slabMaterial.side = FrontSide;
+    slabMaterial.depthWrite = true;
+    slabMaterial.needsUpdate = true;
+    slabMaterialCache.set(cacheKey, material);
+    return material;
+}
+export function buildSlabGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const group = new Group();
+    const merged = generateSlabGeometry(node, slabPolygonContextFromGeometry(ctx));
+    const { top, side } = splitSlabFacesByFacing(merged);
+    merged.dispose();
+    const elevation = node.elevation ?? 0.05;
+    // One mesh per slot, each tagged with its slot id so the unified slot paint
+    // resolves the hit (`resolveRole` reads `userData.slotId`) and previews it.
+    for (const [slotId, geometry] of [
+        ['surface', top],
+        ['side', side],
+    ]) {
+        const material = getSlabSlotMaterial(node, slotId, shading, textures, colorPreset, sceneTheme, ctx?.materials);
+        const mesh = new Mesh(geometry, material);
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        mesh.userData.slotId = slotId;
+        if (elevation < 0)
+            mesh.position.y = elevation;
+        group.add(mesh);
+    }
+    return group;
+}

package/dist/slab/hole-editor.d.ts

@@ -0,0 +1,14 @@
+import { type SlabNode } from '@pascal-app/core';
+/**
+ * Phase 5 Stage D — slab hole editor (registry-driven).
+ *
+ * Edits a specific hole polygon inside a slab. Mounted by ToolManager
+ * via `def.affordanceTools['hole-edit']` when `useEditor.editingHole`
+ * is set on the selected slab.
+ */
+export declare const SlabHoleEditor: React.FC<{
+    slabId: SlabNode['id'];
+    holeIndex: number;
+}>;
+export default SlabHoleEditor;
+//# sourceMappingURL=hole-editor.d.ts.map

package/dist/slab/hole-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hole-editor.d.ts","sourceRoot":"","sources":["../../src/slab/hole-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAkC,MAAM,kBAAkB,CAAA;AAKhG;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgElF,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/slab/hole-editor.js

@@ -0,0 +1,54 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolveLevelId, useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { PolygonEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect } from 'react';
+/**
+ * Phase 5 Stage D — slab hole editor (registry-driven).
+ *
+ * Edits a specific hole polygon inside a slab. Mounted by ToolManager
+ * via `def.affordanceTools['hole-edit']` when `useEditor.editingHole`
+ * is set on the selected slab.
+ */
+export const SlabHoleEditor = ({ slabId, holeIndex, }) => {
+    const slabNode = useScene((s) => s.nodes[slabId]);
+    const updateNode = useScene((s) => s.updateNode);
+    const markDirty = useScene((s) => s.markDirty);
+    const setSelection = useViewer((s) => s.setSelection);
+    const slab = slabNode?.type === 'slab' ? slabNode : null;
+    const holes = slab?.holes || [];
+    const hole = holes[holeIndex];
+    const metadata = slab?.holeMetadata?.[holeIndex];
+    const handlePolygonChange = useCallback((newPolygon) => {
+        const updatedHoles = [...holes];
+        updatedHoles[holeIndex] = newPolygon;
+        updateNode(slabId, { holes: updatedHoles });
+        setSelection({ selectedIds: [slabId] });
+    }, [slabId, holeIndex, holes, updateNode, setSelection]);
+    // Live-preview the in-flight hole onto the slab via
+    // `useLiveNodeOverrides.holes` so `GeometrySystem` rebuilds the CSG
+    // cut while the user is still dragging. Single store commit happens
+    // through `handlePolygonChange` on release.
+    const handlePolygonPreview = useCallback((preview) => {
+        if (preview) {
+            const updatedHoles = [...holes];
+            updatedHoles[holeIndex] = preview.map(([x, z]) => [x, z]);
+            useLiveNodeOverrides.getState().set(slabId, { holes: updatedHoles });
+        }
+        else {
+            useLiveNodeOverrides.getState().clear(slabId);
+        }
+        markDirty(slabId);
+    }, [slabId, holeIndex, holes, markDirty]);
+    useEffect(() => {
+        return () => {
+            useLiveNodeOverrides.getState().clear(slabId);
+            useScene.getState().markDirty(slabId);
+        };
+    }, [slabId]);
+    if (!(slab && hole) || hole.length < 3 || metadata?.source !== 'manual')
+        return null;
+    return (_jsx(PolygonEditor, { allowEdgeMove: true, allowPolygonMove: true, color: "#ef4444", levelId: resolveLevelId(slab, useScene.getState().nodes), minVertices: 3, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, polygon: hole, surfaceHeight: slab.elevation ?? 0.05 }));
+};
+export default SlabHoleEditor;

package/dist/slab/index.d.ts

@@ -0,0 +1,3 @@
+export { slabDefinition } from './definition';
+export { SlabNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/slab/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA"}

package/dist/slab/index.js

@@ -0,0 +1,2 @@
+export { slabDefinition } from './definition';
+export { SlabNode } from './schema';

package/dist/slab/move-tool.d.ts

@@ -0,0 +1,6 @@
+import { type SlabNode } from '@pascal-app/core';
+export declare const MoveSlabTool: React.FC<{
+    node: SlabNode;
+}>;
+export default MoveSlabTool;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/slab/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/slab/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAuFzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA+LrD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/slab/move-tool.js

@@ -0,0 +1,232 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { collectAlignmentAnchors, emitter, polygonAnchors, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, projectAlignmentGuidesWorldToActiveBuildingLocal, resolveAlignmentForActiveBuilding, snapBuildingLocalToWorldGrid, snapFenceDraftPoint, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Phase 5 Stage D — slab whole-move tool.
+ *
+ * Live-drag pattern: translate the slab MESH visually via
+ * `sceneRegistry.nodes.get(id).position` + a mirror entry in
+ * `useLiveTransforms`. No `scene.update` during the drag — the slab's
+ * polygon CSG isn't rebuilt per tick. On commit we write the
+ * translated polygon to the scene exactly once and clear the
+ * useLiveTransforms entry. `GeometrySystem` resets `mesh.position` to
+ * (0,0,0) when it rebuilds, so the visual transitions smoothly with
+ * no teleport.
+ *
+ * History stays UNPAUSED during the drag: the scene state isn't
+ * changing (we're only mutating Three.js mesh transforms), so there's
+ * nothing for zundo to record. The single `scene.update` on commit
+ * becomes the single undo step naturally.
+ */
+/** Figma-style alignment-snap threshold (meters), matching the other tools. */
+const ALIGNMENT_THRESHOLD_M = 0.08;
+function translatePolygon(polygon, deltaX, deltaZ) {
+    return polygon.map(([x, z]) => [x + deltaX, z + deltaZ]);
+}
+function getPolygonCenter(polygon) {
+    if (polygon.length === 0)
+        return [0, 0];
+    let sumX = 0;
+    let sumZ = 0;
+    for (const [x, z] of polygon) {
+        sumX += x;
+        sumZ += z;
+    }
+    return [sumX / polygon.length, sumZ / polygon.length];
+}
+function setMeshOffset(id, deltaX, deltaZ) {
+    const mesh = sceneRegistry.nodes.get(id);
+    if (mesh)
+        mesh.position.set(deltaX, 0, deltaZ);
+}
+/**
+ * Distinguish 3D-canvas grid events (which this tool handles) from
+ * 2D floor-plan grid events (which `slabFloorplanMoveTarget` +
+ * `FloorplanRegistryMoveOverlay` Path 1 handle). The 2D scene wraps
+ * everything in `[data-floorplan-scene]`; if the native event's target
+ * is inside that subtree, the event belongs to the 2D mover. Without
+ * this guard, both paths would write the polygon on commit and produce
+ * two history entries / a double-translation.
+ */
+function isFloorplanSourcedEvent(event) {
+    // ThreeEvent (3D) wraps the DOM PointerEvent under `.nativeEvent`;
+    // the 2D emitter passes the raw PointerEvent directly. Cover both.
+    const native = event.nativeEvent;
+    const candidate = native ?? null;
+    const target = candidate?.target ??
+        candidate?.nativeEvent?.target ??
+        null;
+    if (!target || typeof target.closest !== 'function')
+        return false;
+    return target.closest('[data-floorplan-scene]') != null;
+}
+export const MoveSlabTool = ({ node }) => {
+    const activatedAtRef = useRef(Date.now());
+    const originalPolygonRef = useRef(node.polygon.map(([x, z]) => [x, z]));
+    const originalHolesRef = useRef((node.holes ?? []).map((hole) => hole.map(([x, z]) => [x, z])));
+    const originalCenterRef = useRef(getPolygonCenter(originalPolygonRef.current));
+    const dragAnchorRef = useRef(null);
+    const previousGridPosRef = useRef(null);
+    const deltaRef = useRef([0, 0]);
+    const [cursorLocalPos, setCursorLocalPos] = useState(() => {
+        const c = originalCenterRef.current;
+        return [c[0], 0, c[1]];
+    });
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    useEffect(() => {
+        const originalPolygon = originalPolygonRef.current;
+        const originalHoles = originalHolesRef.current;
+        const originalCenter = originalCenterRef.current;
+        const slabId = node.id;
+        const levelNode = node.parentId && useScene.getState().nodes[node.parentId]?.type === 'level'
+            ? useScene.getState().nodes[node.parentId]
+            : null;
+        const levelChildren = levelNode?.children ?? [];
+        const levelWalls = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((child) => child?.type === 'wall');
+        const levelFences = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((child) => child?.type === 'fence');
+        // Alignment candidates — every other alignable object's anchors,
+        // gathered once (the scene graph is stable during the drag).
+        const alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, slabId);
+        let wasCommitted = false;
+        const applyPreview = (deltaX, deltaZ) => {
+            deltaRef.current = [deltaX, deltaZ];
+            // Visual: translate the slab MESH only. No scene mutation, no
+            // polygon rebuild, no React re-render of geometry.
+            setMeshOffset(slabId, deltaX, deltaZ);
+            // useLiveTransforms holds the same delta the direct mesh.position
+            // mutation uses — ParametricNodeRenderer reads it and reconciles
+            // `<group position={liveTransform.position}>` via React. Mismatched
+            // values here cause the two systems to fight per frame (jitter
+            // during drag).
+            useLiveTransforms.getState().set(slabId, {
+                position: [deltaX, 0, deltaZ],
+                rotation: 0,
+            });
+            // Cursor sphere follows the new polygon center (independent of
+            // group position).
+            setCursorLocalPos([originalCenter[0] + deltaX, 0, originalCenter[1] + deltaZ]);
+        };
+        const clearPreview = () => {
+            setMeshOffset(slabId, 0, 0);
+            useLiveTransforms.getState().clear(slabId);
+        };
+        const onGridMove = (event) => {
+            if (isFloorplanSourcedEvent(event))
+                return;
+            const gridStep = getSegmentGridStep();
+            const [localX, localZ] = snapFenceDraftPoint({
+                point: [event.localPosition[0], event.localPosition[2]],
+                walls: levelWalls,
+                fences: levelFences,
+                magnetic: isMagneticSnapActive(),
+                gridSnap: (p) => snapBuildingLocalToWorldGrid(p, gridStep),
+            });
+            if (previousGridPosRef.current &&
+                (localX !== previousGridPosRef.current[0] || localZ !== previousGridPosRef.current[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousGridPosRef.current = [localX, localZ];
+            const anchor = dragAnchorRef.current ?? [localX, localZ];
+            dragAnchorRef.current = anchor;
+            let deltaX = localX - anchor[0];
+            let deltaZ = localZ - anchor[1];
+            // Figma-style alignment snap: align the slab's translated polygon
+            // vertices to other objects' anchors and publish a guide. Guides are
+            // DISPLAYED in every snapping mode (isAlignmentGuideActive); the magnetic
+            // pull into the delta applies only in 'lines' mode (isMagneticSnapActive).
+            if (isAlignmentGuideActive() && alignmentCandidates.length > 0) {
+                const result = resolveAlignmentForActiveBuilding({
+                    moving: polygonAnchors(slabId, translatePolygon(originalPolygon, deltaX, deltaZ)),
+                    candidates: alignmentCandidates,
+                    threshold: ALIGNMENT_THRESHOLD_M,
+                });
+                if (result.snap && isMagneticSnapActive()) {
+                    deltaX += result.snap.dx;
+                    deltaZ += result.snap.dz;
+                }
+                useAlignmentGuides
+                    .getState()
+                    .set(projectAlignmentGuidesWorldToActiveBuildingLocal(result.guides));
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            applyPreview(deltaX, deltaZ);
+        };
+        const onGridClick = (event) => {
+            if (wasCommitted)
+                return;
+            if (isFloorplanSourcedEvent(event))
+                return;
+            if (Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            const [deltaX, deltaZ] = deltaRef.current;
+            wasCommitted = true;
+            if (deltaX !== 0 || deltaZ !== 0) {
+                // Single scene.update — recorded as one undo step (history was
+                // never paused). GeometrySystem rebuilds polygon-driven geometry
+                // and resets the group's transform on the next frame.
+                useScene.getState().updateNode(slabId, {
+                    polygon: translatePolygon(originalPolygon, deltaX, deltaZ),
+                    holes: originalHoles.map((h) => translatePolygon(h, deltaX, deltaZ)),
+                    autoFromWalls: false,
+                });
+                useScene.getState().markDirty(slabId);
+            }
+            // Clear useLiveTransforms but leave mesh.position as-is. The
+            // GeometrySystem rebuild zeros it on the next frame, by which
+            // point the new geometry is in place — visual stays smooth.
+            useLiveTransforms.getState().clear(slabId);
+            useAlignmentGuides.getState().clear();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [slabId] });
+            exitMoveMode();
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            activatedAtRef.current = 0;
+            onGridClick({ nativeEvent: event });
+        };
+        const onCancel = () => {
+            // No scene state to roll back — we never wrote anything. Just
+            // restore the mesh visual.
+            clearPreview();
+            useAlignmentGuides.getState().clear();
+            useViewer.getState().setSelection({ selectedIds: [slabId] });
+            markToolCancelConsumed();
+            exitMoveMode();
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            useAlignmentGuides.getState().clear();
+            if (!wasCommitted) {
+                clearPreview();
+            }
+            else {
+                useLiveTransforms.getState().clear(slabId);
+            }
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+        };
+    }, [exitMoveMode, node.id, node.parentId]);
+    return (_jsx("group", { children: _jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }) }));
+};
+export default MoveSlabTool;

package/dist/slab/paint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare const slabPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/slab/paint.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAiBpB,CAAA"}

package/dist/slab/paint.js

@@ -0,0 +1,26 @@
+import { createSlotPaintCapability, previewGeometrySlot } from '../shared/slot-paint';
+/**
+ * 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.
+ */
+export const slabPaint = createSlotPaintCapability({
+    roomScope: true,
+    resolveRole: ({ hitObject }) => {
+        const slotId = hitObject?.userData?.slotId;
+        return slotId === 'side' ? 'side' : 'surface';
+    },
+    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) => {
+        if (role !== 'surface')
+            return null;
+        const slab = node;
+        if (slab.materialPreset || slab.material) {
+            return { material: slab.material, materialPreset: slab.materialPreset };
+        }
+        return null;
+    },
+});