@pascal-app/nodes 0.1.1

package/dist/slab/boundary-editor.js

@@ -0,0 +1,127 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolveLevelId, useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { boundaryReshapeScope, clearSlabSnapFeedback, getSegmentGridStep, PolygonEditor, resolveSlabEdgeBandSnap, resolveSlabPlanPointSnap, snapScalarToGrid, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect } from 'react';
+/**
+ * Phase 5 Stage D — slab boundary editor (registry-driven).
+ *
+ * Thin wrapper around the shared `PolygonEditor`. Activates when a
+ * slab is selected in structure/select mode (not currently editing a
+ * hole). The heavy lifting — vertex drag, edge slide, snap, history
+ * bracketing — lives in `PolygonEditor` itself.
+ *
+ * Mounted by ToolManager via `def.affordanceTools['boundary-edit']`.
+ *
+ * Drag flow: every pointer tick the editor hands back the in-flight
+ * polygon through `onPolygonPreview`; we mirror it onto
+ * `useLiveNodeOverrides` + `markDirty` so `GeometrySystem` rebuilds
+ * the slab mesh at pointer rate. On release the editor calls
+ * `onPolygonChange` once with the final polygon — that's the single
+ * `updateNode` tracked by undo. The follow-up `onPolygonPreview(null)`
+ * drops the override so subscribers read from the store again.
+ */
+export const SlabBoundaryEditor = ({ slabId }) => {
+    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 slabLevelId = slab ? resolveLevelId(slab, useScene.getState().nodes) : null;
+    const handlePolygonChange = useCallback((newPolygon) => {
+        clearSlabSnapFeedback();
+        updateNode(slabId, { polygon: newPolygon, autoFromWalls: false });
+        setSelection({ selectedIds: [slabId] });
+    }, [slabId, updateNode, setSelection]);
+    const handlePolygonPreview = useCallback((preview) => {
+        if (preview) {
+            useLiveNodeOverrides.getState().set(slabId, {
+                polygon: preview.map(([x, z]) => [x, z]),
+            });
+        }
+        else {
+            clearSlabSnapFeedback();
+            useLiveNodeOverrides.getState().clear(slabId);
+        }
+        markDirty(slabId);
+    }, [slabId, markDirty]);
+    const handleDragCommit = useCallback(() => {
+        clearSlabSnapFeedback();
+    }, []);
+    // A vertex/edge drag is a `boundary` reshape — drive the snapping HUD (the
+    // no-angle 'polygon' set) and keep the idle select hints off-screen.
+    const handleDragStateChange = useCallback((isDragging) => {
+        const scope = useInteractionScope.getState();
+        if (isDragging)
+            scope.begin(boundaryReshapeScope(slabId));
+        else
+            scope.endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
+    }, [slabId]);
+    const resolvePolygonEditorPlanPoint = useCallback((context) => {
+        // Edge drags: `PolygonEditor` translates the edge by the pointer
+        // DELTA from `initialPosition` — the cursor at grab time, which sits
+        // on the edge ARROW ~0.34m outside the edge. A cursor-based wall
+        // snap here therefore commits the edge short of the wall by exactly
+        // that offset while the beacon shows a snap ON the wall. Snap the
+        // CANDIDATE EDGE onto the wall band instead (2D parity: the slab
+        // `move-edge` affordance's `snapEdge`), and hand back a point whose
+        // normal projection encodes the final travel.
+        if (context.mode === 'edge' && context.edgeIndex !== undefined) {
+            const a = context.initialPolygon[context.edgeIndex];
+            const b = context.initialPolygon[(context.edgeIndex + 1) % context.initialPolygon.length];
+            if (a && b) {
+                const dx = b[0] - a[0];
+                const dz = b[1] - a[1];
+                const length = Math.hypot(dx, dz);
+                if (length > 1e-6) {
+                    // Same convention as PolygonEditor's getEdgeNormal.
+                    const normalX = -dz / length;
+                    const normalZ = dx / length;
+                    const rawDelta = (context.rawPoint[0] - context.initialPosition[0]) * normalX +
+                        (context.rawPoint[1] - context.initialPosition[1]) * normalZ;
+                    const projection = snapScalarToGrid(rawDelta, getSegmentGridStep());
+                    const candidate = [
+                        [a[0] + normalX * projection, a[1] + normalZ * projection],
+                        [b[0] + normalX * projection, b[1] + normalZ * projection],
+                    ];
+                    const snap = resolveSlabEdgeBandSnap({
+                        edge: candidate,
+                        levelId: slabLevelId,
+                        referencePoint: context.rawPoint,
+                    });
+                    const distance = snap
+                        ? (snap.edge[0][0] - a[0]) * normalX + (snap.edge[0][1] - a[1]) * normalZ
+                        : projection;
+                    return [
+                        context.initialPosition[0] + normalX * distance,
+                        context.initialPosition[1] + normalZ * distance,
+                    ];
+                }
+            }
+        }
+        return resolveSlabPlanPointSnap({
+            rawPoint: context.rawPoint,
+            fallbackPoint: context.gridPoint,
+            levelId: slabLevelId,
+            excludeId: slabId,
+        }).point;
+    }, [slabId, slabLevelId]);
+    // Guarantee the override clears if the editor unmounts mid-drag
+    // (selection change, mode switch) so the slab mesh doesn't get stuck
+    // on a stale polygon.
+    useEffect(() => {
+        return () => {
+            clearSlabSnapFeedback();
+            useLiveNodeOverrides.getState().clear(slabId);
+            useScene.getState().markDirty(slabId);
+            useInteractionScope
+                .getState()
+                .endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
+        };
+    }, [slabId]);
+    if (!slab?.polygon || slab.polygon.length < 3)
+        return null;
+    return (_jsx(PolygonEditor, { allowEdgeMove: true, color: "#a3a3a3", levelId: slabLevelId ?? undefined, minVertices: 3, onDragCommit: handleDragCommit, onDragStateChange: handleDragStateChange, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, polygon: slab.polygon, resolvePlanPoint: resolvePolygonEditorPlanPoint, surfaceHeight: slab.elevation ?? 0.05 }));
+};
+export default SlabBoundaryEditor;

package/dist/slab/definition.d.ts

@@ -0,0 +1,20 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { SlabNode } from './schema';
+/**
+ * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
+ * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
+ * mounts the empty group. No per-kind renderer or system file.
+ *
+ * Capabilities:
+ *  - **No `movable`**: slab's "move" today is whole-slab translation via
+ *    legacy `MoveSlabTool`, which integrates with the floor-plan boundary /
+ *    hole editors. Capability-driven dispatch keeps the legacy mover.
+ *  - **`surfaces.top`**: items host on the slab top at `elevation`.
+ *  - `selectable`, `duplicable`, `deletable` standard.
+ *
+ * Relations:
+ *  - `hosts: ['item']` — items mount on the slab top.
+ *  - `cascadeDelete: 'descendants'` — deleting a slab removes hosted items.
+ */
+export declare const slabDefinition: NodeDefinition<typeof SlabNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAczB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAqGnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA+G1D,CAAA"}

package/dist/slab/definition.js

@@ -0,0 +1,218 @@
+import { pointInPolygon2D, } from '@pascal-app/core';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { buildSlabFloorplan } from './floorplan';
+import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances';
+import { slabFloorplanMoveTarget } from './floorplan-move';
+import { buildSlabGeometry } from './geometry';
+import { slabPaint } from './paint';
+import { slabParametrics } from './parametrics';
+import { slabQuickMeasurement } from './quick-measurement';
+import { SlabNode } from './schema';
+import { slabSlots } from './slots';
+const HEIGHT_HANDLE_OFFSET = 0.22;
+const MIN_SLAB_ELEVATION = -1;
+function polygonVertexAverage(polygon) {
+    if (polygon.length === 0)
+        return [0, 0];
+    let cx = 0;
+    let cz = 0;
+    for (const [x, z] of polygon) {
+        cx += x;
+        cz += z;
+    }
+    return [cx / polygon.length, cz / polygon.length];
+}
+function pointIsOnSolidSlab(point, slab) {
+    if (!pointInPolygon2D(point, slab.polygon, { includeBoundary: false }))
+        return false;
+    return !(slab.holes ?? []).some((hole) => hole.length >= 3 && pointInPolygon2D(point, hole, { includeBoundary: true }));
+}
+function slabHandleAnchor(slab) {
+    const polygon = slab.polygon ?? [];
+    const fallback = polygonVertexAverage(polygon);
+    if (polygon.length < 3)
+        return fallback;
+    if (pointIsOnSolidSlab(fallback, slab))
+        return fallback;
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [x, z] of polygon) {
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minZ = Math.min(minZ, z);
+        maxZ = Math.max(maxZ, z);
+    }
+    const candidates = [];
+    for (const point of polygon) {
+        candidates.push([
+            fallback[0] + (point[0] - fallback[0]) * 0.35,
+            fallback[1] + (point[1] - fallback[1]) * 0.35,
+        ]);
+    }
+    const steps = 12;
+    for (let xi = 1; xi < steps; xi += 1) {
+        const x = minX + ((maxX - minX) * xi) / steps;
+        for (let zi = 1; zi < steps; zi += 1) {
+            const z = minZ + ((maxZ - minZ) * zi) / steps;
+            candidates.push([x, z]);
+        }
+    }
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        if (!pointIsOnSolidSlab(candidate, slab))
+            continue;
+        const dx = candidate[0] - fallback[0];
+        const dz = candidate[1] - fallback[1];
+        const distance = dx * dx + dz * dz;
+        if (distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    return best ?? fallback;
+}
+// Slab height arrow — vertical chevron on solid slab surface near the
+// polygon center. Drags elevation through zero: positive values extrude
+// upward from ground while negative values create a recessed floor whose
+// depth follows the pointer. Same registry-handle pipeline as the column
+// height arrow, so live override + commit-on-release come for free.
+function slabHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SLAB_ELEVATION,
+        currentValue: (n) => n.elevation ?? 0.05,
+        apply: (_n, newValue) => ({ elevation: newValue }),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                const elevation = n.elevation ?? 0.05;
+                return [cx, elevation + HEIGHT_HANDLE_OFFSET, cz];
+            },
+        },
+    };
+}
+function slabHandles(_node) {
+    return [slabHeightHandle()];
+}
+/**
+ * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
+ * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
+ * mounts the empty group. No per-kind renderer or system file.
+ *
+ * Capabilities:
+ *  - **No `movable`**: slab's "move" today is whole-slab translation via
+ *    legacy `MoveSlabTool`, which integrates with the floor-plan boundary /
+ *    hole editors. Capability-driven dispatch keeps the legacy mover.
+ *  - **`surfaces.top`**: items host on the slab top at `elevation`.
+ *  - `selectable`, `duplicable`, `deletable` standard.
+ *
+ * Relations:
+ *  - `hosts: ['item']` — items mount on the slab top.
+ *  - `cascadeDelete: 'descendants'` — deleting a slab removes hosted items.
+ */
+export const slabDefinition = {
+    kind: 'slab',
+    snapProfile: 'structural',
+    schemaVersion: 1,
+    schema: SlabNode,
+    category: 'structure',
+    surfaceRole: 'floor',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        polygon: [],
+        holes: [],
+        holeMetadata: [],
+        elevation: 0.05,
+        autoFromWalls: false,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            top: { height: (n) => n.elevation },
+        },
+        duplicable: true,
+        deletable: true,
+        // Unified slot model: one paintable floor surface with a declared default,
+        // painted through the registry `capabilities.paint` dispatch like the shelf.
+        slots: () => slabSlots(),
+        paint: slabPaint,
+    },
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    parametrics: slabParametrics,
+    handles: slabHandles,
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'slab',
+            height: node.elevation,
+            label: 'Slab',
+            polygon: node.polygon,
+        }),
+        quickMeasure: (node) => slabQuickMeasurement(node),
+    },
+    // Stage D: kind-owned placement tool. Multi-click polygon drawing
+    // with 15° angle snap (Shift to defeat).
+    tool: () => import('./tool'),
+    // Stage D — all four slab drag-affordances live in this folder.
+    // boundary-edit / hole-edit are thin <PolygonEditor> wrappers; move
+    // is a 1:1 port of the legacy MoveSlabTool (scene.update per tick
+    // with the same history dance, no live-drag exception).
+    affordanceTools: {
+        'boundary-edit': () => import('./boundary-editor'),
+        'hole-edit': () => import('./hole-editor'),
+        move: () => import('./move-tool'),
+    },
+    // Stage B: pure geometry function.
+    geometry: buildSlabGeometry,
+    // Dependency tracker only — dirties level slabs when walls / sibling
+    // slabs change, since the renderable polygon derives from level context.
+    system: {
+        module: () => import('./system'),
+        priority: 4,
+    },
+    // The fill reads walls + sibling slabs via ctx (per-edge render offsets),
+    // so committed sibling edits must invalidate the cached floor-plan entry.
+    floorplanDependsOnSiblings: true,
+    // Stage C: floor-plan rendering. Legacy `slabPolygons` short-circuits
+    // to [] when slab is registered (see floorplan-panel.tsx).
+    floorplan: buildSlabFloorplan,
+    // 2D move handler — translates polygon by cursor delta from first
+    // pointer position. The 3D `MoveSlabTool` in `affordanceTools.move`
+    // skips events sourced from the 2D scene so the two paths don't
+    // double-write on commit.
+    floorplanMoveTarget: slabFloorplanMoveTarget,
+    // Sister to `affordanceTools['boundary-edit']` (the 3D `PolygonEditor`
+    // wrapper). The 2D version edits the same `polygon` field via SVG
+    // pointer events on the vertex handles emitted by `def.floorplan`.
+    floorplanAffordances: {
+        'move-vertex': slabMoveVertexAffordance,
+        'add-vertex': slabAddVertexAffordance,
+        'move-edge': slabMoveEdgeAffordance,
+        'delete-vertex': slabDeleteVertexAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Trace slab outline' },
+        { key: 'Enter', label: 'Finish slab', minDraftVertices: 3 },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Slab',
+        description: 'A polygon-bounded floor surface that hosts items on top.',
+        icon: { kind: 'url', src: '/icons/floor.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 30,
+    },
+    mcp: {
+        description: 'A polygon-bounded slab (floor) with optional cutout holes.',
+    },
+};

package/dist/slab/floorplan-affordances.d.ts

@@ -0,0 +1,177 @@
+export declare const slabMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `slab_${string}`;
+    type: "slab";
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    elevation: number;
+    autoFromWalls: boolean;
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+}>;
+export declare const slabAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `slab_${string}`;
+    type: "slab";
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    elevation: number;
+    autoFromWalls: boolean;
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+}>;
+export declare const slabMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `slab_${string}`;
+    type: "slab";
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    elevation: number;
+    autoFromWalls: boolean;
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+}>;
+export declare const slabDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `slab_${string}`;
+    type: "slab";
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    elevation: number;
+    autoFromWalls: boolean;
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+}>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/slab/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-affordances.ts"],"names":[],"mappings":"AAgEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,CAAA;AACD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA"}

package/dist/slab/floorplan-affordances.js

@@ -0,0 +1,52 @@
+import { resolveLevelId } from '@pascal-app/core';
+import { resolveSlabEdgeBandSnap, resolveSlabPlanPointSnap } from '@pascal-app/editor';
+import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance';
+/**
+ * 2D affordances for slab. Four operations, each accepting an
+ * optional `holeIndex` in the payload so they target the boundary
+ * polygon or a specific hole:
+ *
+ *   - `move-vertex` — drag an existing vertex.
+ *   - `add-vertex` — insert a new vertex at a midpoint then drag.
+ *   - `move-edge` — drag a whole edge perpendicular to itself.
+ *   - `delete-vertex` — remove a double-clicked vertex down to three.
+ *
+ * Holes are surfaced inline alongside the boundary in `def.floorplan`
+ * (no separate "hole edit mode" state machine like the legacy) — when
+ * the slab is selected, every hole's handles appear at the same time.
+ * Simpler model, no UX downside in practice.
+ */
+const slabSnapOptions = {
+    boundaryCommitData: { autoFromWalls: false },
+    resolvePlanPoint({ node, nodes, rawPoint, fallbackPoint, mode, }) {
+        // Edge drags snap the EDGE, not the cursor (`snapEdge` below): a
+        // cursor-based wall snap here would bake the pointer's grab offset
+        // from the edge line into the commit — the beacon shows a snap on
+        // the wall while the released edge stops short by that offset.
+        if (mode === 'move-edge')
+            return fallbackPoint;
+        const sceneNodes = nodes;
+        return resolveSlabPlanPointSnap({
+            rawPoint,
+            fallbackPoint,
+            levelId: resolveLevelId(node, sceneNodes),
+            excludeId: node.id,
+            nodes: sceneNodes,
+            // Magnetic wall-snap/alignment gates on `isMagneticSnapActive()` (the
+            // `lines` mode), so no Shift or Alt snap bypass.
+        }).point;
+    },
+    snapEdge({ node, nodes, edge, rawPoint }) {
+        const sceneNodes = nodes;
+        return (resolveSlabEdgeBandSnap({
+            edge,
+            levelId: resolveLevelId(node, sceneNodes),
+            nodes: sceneNodes,
+            referencePoint: rawPoint,
+        })?.edge ?? null);
+    },
+};
+export const slabMoveVertexAffordance = createPolygonVertexAffordance('slab', slabSnapOptions);
+export const slabAddVertexAffordance = createPolygonAddVertexAffordance('slab', slabSnapOptions);
+export const slabMoveEdgeAffordance = createPolygonMoveEdgeAffordance('slab', slabSnapOptions);
+export const slabDeleteVertexAffordance = createPolygonDeleteVertexAffordance('slab', slabSnapOptions);

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

@@ -0,0 +1,12 @@
+import type { FloorplanMoveTarget, SlabNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for slab. Delegates to the shared polygon
+ * centroid-pivot mover: the slab's centroid snaps to the (grid-snapped,
+ * Figma-aligned) cursor — the same pivot semantics as a regular item's
+ * origin — instead of the old grab-relative delta. See
+ * `shared/polygon-centroid-move.ts` for the live-drag / commit rationale.
+ *
+ * `meshY = 0`: `GeometrySystem` parks the slab group at y=0 on rebuild.
+ */
+export declare const slabFloorplanMoveTarget: FloorplanMoveTarget<SlabNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGrE;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAS9D,CAAA"}

package/dist/slab/floorplan-move.js

@@ -0,0 +1,19 @@
+import { createPolygonCentroidMoveTarget } from '../shared/polygon-centroid-move';
+/**
+ * 2D floor-plan move handler for slab. Delegates to the shared polygon
+ * centroid-pivot mover: the slab's centroid snaps to the (grid-snapped,
+ * Figma-aligned) cursor — the same pivot semantics as a regular item's
+ * origin — instead of the old grab-relative delta. See
+ * `shared/polygon-centroid-move.ts` for the live-drag / commit rationale.
+ *
+ * `meshY = 0`: `GeometrySystem` parks the slab group at y=0 on rebuild.
+ */
+export const slabFloorplanMoveTarget = ({ node, nodes }) => createPolygonCentroidMoveTarget({
+    node,
+    nodes,
+    meshY: 0,
+    // A user-dragged slab is a manual edit. Clear `autoFromWalls` so the
+    // space-detection sync doesn't recompute the polygon from the wall loop
+    // and snap the slab back to its original position.
+    extraCommitData: node.autoFromWalls ? { autoFromWalls: false } : undefined,
+});

package/dist/slab/floorplan.d.ts

@@ -0,0 +1,20 @@
+import { type FloorplanGeometry, type GeometryContext, type SlabNode } 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 declare function buildSlabFloorplan(node: SlabNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAyFjG"}