@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/slab/definition.d.ts

@@ -1,20 +1,290 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { SlabNode } from './schema.js';
-/**
- * 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>;
+export declare const slabDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`slab_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"slab">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    holes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+    holeMetadata: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        source: import("zod").ZodDefault<import("zod").ZodEnum<{
+            elevator: "elevator";
+            "floor-opening": "floor-opening";
+            manual: "manual";
+            room: "room";
+            stair: "stair";
+        }>>;
+        openingId: import("zod").ZodOptional<import("zod").ZodString>;
+        stairId: import("zod").ZodOptional<import("zod").ZodString>;
+        elevatorId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    elevation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    floorHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    referenceFloorElevation: import("zod").ZodOptional<import("zod").ZodNumber>;
+    foundation: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            none: "none";
+            solid: "solid";
+        }>;
+        material: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+                brick: "brick";
+                concrete: "concrete";
+                custom: "custom";
+                glass: "glass";
+                marble: "marble";
+                metal: "metal";
+                plaster: "plaster";
+                tile: "tile";
+                white: "white";
+                wood: "wood";
+            }>>>;
+            properties: import("zod").ZodOptional<import("zod").ZodObject<{
+                color: import("zod").ZodDefault<import("zod").ZodString>;
+                roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+                metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+                opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+                transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    back: "back";
+                    double: "double";
+                    front: "front";
+                }>>;
+            }, import("zod/v4/core").$strip>>;
+            texture: import("zod").ZodOptional<import("zod").ZodObject<{
+                url: import("zod").ZodString;
+                repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+                offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+                normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+                bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+                bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$strip>>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    recessed: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    recessedRimElevation: import("zod").ZodOptional<import("zod").ZodNumber>;
+    fillToTerrain: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    boundary: import("zod").ZodOptional<import("zod").ZodLiteral<"auto">>;
+    support: import("zod").ZodOptional<import("zod").ZodLiteral<"open">>;
+    plateRole: import("zod").ZodOptional<import("zod").ZodEnum<{
+        base: "base";
+        platform: "platform";
+        sunken: "sunken";
+    }>>;
+    railing: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        start: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        end: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    }, import("zod/v4/core").$strip>>>;
+    zoneIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    associatedZoneIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    autoFromWalls: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    surfaceScript: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"script">;
+        meta: import("zod").ZodOptional<import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            parent: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        language: import("zod").ZodDefault<import("zod").ZodEnum<{
+            bpy: "bpy";
+            three: "three";
+        }>>;
+        script: import("zod").ZodString;
+        params: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>>;
+        artifact: import("zod").ZodString;
+        manifest: import("zod").ZodObject<{
+            bounds: import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>;
+            params: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                kind: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>;
+                default: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>;
+                min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                step: import("zod").ZodOptional<import("zod").ZodNumber>;
+                unit: import("zod").ZodOptional<import("zod").ZodString>;
+                options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>>;
+            parts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                type: import("zod").ZodOptional<import("zod").ZodString>;
+                bounds: import("zod").ZodOptional<import("zod").ZodObject<{
+                    min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            surfaces: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                y: import("zod").ZodNumber;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            slots: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                color: import("zod").ZodOptional<import("zod").ZodString>;
+                roughness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                metalness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                transparent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                emissive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>>;
+            anchors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                normal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            lights: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                color: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+                distance: import("zod").ZodOptional<import("zod").ZodNumber>;
+                spot: import("zod").ZodOptional<import("zod").ZodObject<{
+                    direction: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    angle: import("zod").ZodNumber;
+                    softness: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>;
+                shadows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                glow: import("zod").ZodOptional<import("zod").ZodObject<{
+                    size: import("zod").ZodNumber;
+                    strength: import("zod").ZodDefault<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            undersides: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                plane: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+            animations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                duration: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                host: import("zod").ZodEnum<{
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                    slab: "slab";
+                    wall: "wall";
+                }>;
+                polygon: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>;
+                minY: import("zod").ZodNumber;
+                maxY: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutout: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            collider: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            shape: import("zod").ZodOptional<import("zod").ZodObject<{
+                tolerance: import("zod").ZodNumber;
+                bands: import("zod").ZodArray<import("zod").ZodObject<{
+                    y0: import("zod").ZodNumber;
+                    y1: import("zod").ZodNumber;
+                    polygons: import("zod").ZodArray<import("zod").ZodObject<{
+                        outer: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                        holes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            triangles: import("zod").ZodNumber;
+            coverage: import("zod").ZodOptional<import("zod").ZodNumber>;
+            uncovered: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>;
+        images: import("zod").ZodOptional<import("zod").ZodObject<{
+            artifact: import("zod").ZodString;
+            thumbnail: import("zod").ZodString;
+            floorPlan: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        inputs: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,cAAc,EAMpB,MAAM,kBAAkB,CAAA;AA+BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyNnC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkJ1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/slab/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { SlabNode } from './schema.js';
+export declare const slabEditContribution: NodeEditContribution<typeof SlabNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/slab/definition.edit.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAmBvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA0NxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAoDtE,CAAA"}

package/dist/slab/definition.edit.js

@@ -0,0 +1,230 @@
+import { MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, syncStairRises, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
+import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit.js';
+import { buildSlabFloorplan } from './floorplan.js';
+import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances.js';
+import { slabFloorplanMoveTarget } from './floorplan-move.js';
+import { slabPaint } from './paint.js';
+import { slabParametrics } from './parametrics.js';
+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;
+}
+function slabElevationGuideSource(slab) {
+    return {
+        nodeId: slab.id,
+        levelId: slab.parentId,
+        anchor: slabHandleAnchor(slab),
+    };
+}
+function slabChangePreviewOverrides(slab, patch, sceneApi) {
+    const next = { ...slab, ...patch };
+    const nodes = { ...sceneApi.nodes(), [slab.id]: next };
+    const previews = new Map();
+    markSlabChangeDependents(slab, next, nodes, (id) => previews.set(id, {}));
+    for (const update of syncStairRises(nodes)) {
+        const segment = nodes[update.id];
+        if (segment?.type !== 'stair-segment' ||
+            !segment.parentId ||
+            !previews.has(segment.parentId)) {
+            continue;
+        }
+        previews.set(update.id, update.data);
+    }
+    return [...previews];
+}
+function slabRecessedDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SLAB_ELEVATION,
+        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n),
+        currentValue: (n) => n.elevation ?? 0.05,
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newValue) => applySlabTopChange(n, newValue),
+        previewOverrides: (n, newValue, sceneApi) => slabChangePreviewOverrides(n, applySlabTopChange(n, newValue), sceneApi),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                const elevation = n.elevation ?? 0.05;
+                return [cx, elevation + HEIGHT_HANDLE_OFFSET, cz];
+            },
+        },
+    };
+}
+function slabThicknessHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SLAB_THICKNESS,
+        max: (n, sceneApi) => Math.max(MIN_SLAB_THICKNESS, slabElevationUpperBound(sceneApi.nodes(), n) - getSlabBaseElevation(n)),
+        currentValue: (n) => n.thickness ?? 0.05,
+        magneticSnap: (n, newThickness, sceneApi) => {
+            const base = getSlabBaseElevation(n);
+            const snappedTop = resolveStructuralElevationSnap(slabElevationGuideSource(n), base + newThickness, sceneApi.nodes());
+            return Math.max(MIN_SLAB_THICKNESS, snappedTop - base);
+        },
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newThickness) => applySlabThicknessChange(n, newThickness),
+        previewOverrides: (n, newThickness, sceneApi) => slabChangePreviewOverrides(n, applySlabThicknessChange(n, newThickness), sceneApi),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                return [cx, (n.elevation ?? 0.05) + HEIGHT_HANDLE_OFFSET, cz];
+            },
+        },
+    };
+}
+function slabBaseElevationHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        gridSnap: true,
+        min: (n) => MIN_SLAB_ELEVATION - (n.thickness ?? 0.05),
+        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n) - (n.thickness ?? 0.05),
+        currentValue: (n) => getSlabBaseElevation(n),
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), getSlabBaseElevation(n), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (n, newBase) => applySlabBaseElevationChange(n, newBase),
+        previewOverrides: (n, newBase, sceneApi) => slabChangePreviewOverrides(n, applySlabBaseElevationChange(n, newBase), sceneApi),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = slabHandleAnchor(n);
+                return [cx, getSlabBaseElevation(n), cz];
+            },
+        },
+    };
+}
+function slabHandles(node) {
+    // A footprint's floor (base plate) has one control, its height above the
+    // ground, drawn by the editor's footprint height handle; room plates are
+    // reached through their room. Only user-drawn slabs keep these handles.
+    if (node.plateRole)
+        return [];
+    return node.recessed
+        ? [slabRecessedDepthHandle()]
+        : [slabThicknessHandle(), slabBaseElevationHandle()];
+}
+export const slabEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'slab',
+        },
+        'pascal:editor/floorplan': {
+            selectionCounterparts: sameOutlineSurfaceCounterparts,
+        },
+    },
+    capabilities: {
+        paint: slabPaint,
+    },
+    parametrics: slabParametrics,
+    handles: slabHandles,
+    // Stage D: kind-owned placement tool. Multi-click polygon drawing
+    // with 15° angle snap (Shift to defeat).
+    tool: () => import('./tool.js'),
+    // 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.js'),
+        'hole-edit': () => import('./hole-editor.js'),
+        move: () => import('./move-tool.js'),
+    },
+    // 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' },
+    ],
+};