@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/ceiling/definition.d.ts

@@ -1,20 +1,153 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { CeilingNode } from './schema.js';
-/**
- * Ceiling — Phase 5 batch kind, polygon-based. Structurally similar to
- * slab but with React-rendered hosted children + TSL shader materials +
- * named meshes that other systems poke (`getObjectByName('ceiling-grid')`).
- *
- * **Stage B intentionally skipped**: pure `def.geometry` extraction
- * would lose the React children rendering (hosted items) and the
- * named-mesh structure. Ceiling keeps `def.renderer` as its escape hatch
- * ("Opting out of a generic path" in wiki/architecture/node-definitions.md).
- * Renderer wraps the legacy CeilingRenderer; system wraps the legacy
- * CeilingSystem.
- *
- * **Stage C completed**: `def.floorplan` builder draws the ceiling
- * polygon as a dashed outline in floor plan; legacy `ceilingPolygons`
- * short-circuits to [] when ceiling is registered.
- */
-export declare const ceilingDefinition: NodeDefinition<typeof CeilingNode>;
+export declare const ceilingDefinition: 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<`ceiling_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"ceiling">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`item_${string}`>>, import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`procedural-item_${string}`>>]>>>;
+    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>>>;
+    openingIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+    buildUp: import("zod").ZodOptional<import("zod").ZodObject<{
+        presetId: import("zod").ZodOptional<import("zod").ZodString>;
+        finish: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+                drywall: "drywall";
+                plaster: "plaster";
+                "wood-plank": "wood-plank";
+            }>;
+            thickness: import("zod").ZodNumber;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        framing: import("zod").ZodOptional<import("zod").ZodObject<{
+            system: import("zod").ZodEnum<{
+                joists: "joists";
+                "truss-chords": "truss-chords";
+            }>;
+            size: import("zod").ZodEnum<{
+                "2x10": "2x10";
+                "2x12": "2x12";
+                "2x4": "2x4";
+                "2x6": "2x6";
+                "2x8": "2x8";
+            }>;
+            spacing: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+        decking: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+                osb: "osb";
+                plywood: "plywood";
+            }>;
+            thickness: import("zod").ZodNumber;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        insulation: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+                batt: "batt";
+                blown: "blown";
+                rigid: "rigid";
+            }>;
+            thickness: import("zod").ZodNumber;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    regions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+        finish: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>;
+    }, import("zod/v4/core").$strip>>>;
+    boundary: import("zod").ZodOptional<import("zod").ZodLiteral<"auto">>;
+    zoneId: import("zod").ZodOptional<import("zod").ZodString>;
+    autoFromWalls: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAyBzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA+EtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CA0HhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG7B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.edit.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAavE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AA+E3C,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CA+C5E,CAAA"}

package/dist/ceiling/definition.edit.js

@@ -0,0 +1,123 @@
+import { resolveCeilingHeight, useScene, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
+import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances.js';
+import { ceilingFloorplanMoveTarget } from './floorplan-move.js';
+import { CEILING_HANDLE_MIN_HEIGHT, ceilingHeightRange } from './height-bounds.js';
+import { ceilingPaint } from './paint.js';
+import { ceilingPanelModel } from './panel-model.js';
+import { ceilingParametrics } from './parametrics.js';
+const HEIGHT_HANDLE_OFFSET = 0.22;
+// Ceilings no longer drive the storey height; the stored level height
+// does. Height writes clamp under min(storey plane, lowest underside of
+// any covering slab from the level above) − CEILING_CLAMP_MARGIN, so a
+// ceiling can poke into neither the level above nor a deck hanging from
+// it (clamp, never ask). On a level above grade the ceiling may hang below
+// the level floor down to grade (soffits owned by a roof level).
+function ceilingHeightBounds(n, sceneApi) {
+    return ceilingHeightRange(n, sceneApi.nodes(), CEILING_HANDLE_MIN_HEIGHT);
+}
+function ceilingPolygonCenter(n) {
+    const polygon = n.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 ceilingElevationGuideSource(n) {
+    return {
+        nodeId: n.id,
+        levelId: n.parentId,
+        anchor: ceilingPolygonCenter(n),
+    };
+}
+// Ceiling height arrow — vertical chevron at the polygon centroid,
+// hovering just above the ceiling plane. Drags the `height` field
+// (the Y position of the ceiling surface). `anchor: 'min'` so dragging
+// the cursor upward grows the value directly. Live override + commit
+// flow comes from the shared registry arrow pipeline.
+//
+// `currentValue` resolves through `resolveCeilingHeight`, and `apply`
+// always writes `height` — so dragging a follows-mode ceiling converts
+// it to an explicit custom height, mirroring the wall top-drag.
+//
+// The placement Y is in *mesh-local* coords. CeilingSystem already
+// parks `mesh.position.y = resolved height - 0.01`, so the local Y is
+// just the offset above that plane (NOT `height + offset` — that
+// would double-add the height and push the arrow off-screen).
+function ceilingHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).min,
+        max: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).max,
+        currentValue: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(ceilingElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(ceilingElevationGuideSource(n), resolveCeilingHeight(n, sceneApi.nodes()), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (_n, newValue) => ({ height: newValue }),
+        placement: {
+            position: (n) => {
+                const [cx, cz] = ceilingPolygonCenter(n);
+                return [cx, HEIGHT_HANDLE_OFFSET, cz];
+            },
+        },
+    };
+}
+function ceilingHandles(_node) {
+    return [ceilingHeightHandle()];
+}
+export const ceilingEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'ceiling',
+            raycast: 'underside',
+        },
+        'pascal:editor/floorplan': {
+            selectionCounterparts: sameOutlineSurfaceCounterparts,
+        },
+        [PANEL_MODEL_EXTENSION]: ceilingPanelModel,
+    },
+    capabilities: {
+        paint: ceilingPaint,
+    },
+    parametrics: ceilingParametrics,
+    handles: ceilingHandles,
+    // Stage D: kind-owned placement tool. Multi-click polygon drawing
+    // with a vertical TSL-gradient connector + ground-shadow lines.
+    tool: () => import('./tool.js'),
+    // Stage D — all four ceiling drag-affordances live in this folder.
+    // 1:1 port of the legacy tools (scene.update per tick + history
+    // dance + preview fill/outline overlay on move).
+    affordanceTools: {
+        'boundary-edit': () => import('./boundary-editor.js'),
+        'hole-edit': () => import('./hole-editor.js'),
+        move: () => import('./move-tool.js'),
+    },
+    floorplanDependsOnSiblings: true,
+    // 2D move handler — translates polygon by cursor delta from first
+    // pointer position. Mirror of slab; 3D `MoveCeilingTool` skips
+    // 2D-sourced grid events so they don't double-write on commit.
+    floorplanMoveTarget: ceilingFloorplanMoveTarget,
+    // Sister to `affordanceTools['boundary-edit']`. Same `polygon` field;
+    // SVG vertex handles dispatch to this affordance via the floor-plan
+    // registry layer.
+    floorplanAffordances: {
+        'move-vertex': ceilingMoveVertexAffordance,
+        'add-vertex': ceilingAddVertexAffordance,
+        'move-edge': ceilingMoveEdgeAffordance,
+        'delete-vertex': ceilingDeleteVertexAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Trace ceiling outline' },
+        { key: 'Enter', label: 'Finish ceiling', minDraftVertices: 3 },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/ceiling/definition.js

@@ -1,207 +1,4 @@
-import { ceilingSlots, resolveCeilingHeight, useScene, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { surfaceBatchable } from '../shared/node-batch/batchable.js';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
-import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
-import { buildCeilingFloorplan } from './floorplan.js';
-import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances.js';
-import { ceilingFloorplanMoveTarget } from './floorplan-move.js';
-import { CEILING_HANDLE_MIN_HEIGHT, ceilingHeightRange } from './height-bounds.js';
-import { ceilingPaint } from './paint.js';
-import { ceilingPanelModel } from './panel-model.js';
-import { ceilingParametrics } from './parametrics.js';
-import { CeilingNode } from './schema.js';
-const HEIGHT_HANDLE_OFFSET = 0.22;
-// Ceilings no longer drive the storey height; the stored level height
-// does. Height writes clamp under min(storey plane, lowest underside of
-// any covering slab from the level above) − CEILING_CLAMP_MARGIN, so a
-// ceiling can poke into neither the level above nor a deck hanging from
-// it (clamp, never ask). On a level above grade the ceiling may hang below
-// the level floor down to grade (soffits owned by a roof level).
-function ceilingHeightBounds(n, sceneApi) {
-    return ceilingHeightRange(n, sceneApi.nodes(), CEILING_HANDLE_MIN_HEIGHT);
-}
-function ceilingPolygonCenter(n) {
-    const polygon = n.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 ceilingElevationGuideSource(n) {
-    return {
-        nodeId: n.id,
-        levelId: n.parentId,
-        anchor: ceilingPolygonCenter(n),
-    };
-}
-// Ceiling height arrow — vertical chevron at the polygon centroid,
-// hovering just above the ceiling plane. Drags the `height` field
-// (the Y position of the ceiling surface). `anchor: 'min'` so dragging
-// the cursor upward grows the value directly. Live override + commit
-// flow comes from the shared registry arrow pipeline.
-//
-// `currentValue` resolves through `resolveCeilingHeight`, and `apply`
-// always writes `height` — so dragging a follows-mode ceiling converts
-// it to an explicit custom height, mirroring the wall top-drag.
-//
-// The placement Y is in *mesh-local* coords. CeilingSystem already
-// parks `mesh.position.y = resolved height - 0.01`, so the local Y is
-// just the offset above that plane (NOT `height + offset` — that
-// would double-add the height and push the arrow off-screen).
-function ceilingHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).min,
-        max: (n, sceneApi) => ceilingHeightBounds(n, sceneApi).max,
-        currentValue: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(ceilingElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(ceilingElevationGuideSource(n), resolveCeilingHeight(n, sceneApi.nodes()), sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (_n, newValue) => ({ height: newValue }),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = ceilingPolygonCenter(n);
-                return [cx, HEIGHT_HANDLE_OFFSET, cz];
-            },
-        },
-    };
-}
-function ceilingHandles(_node) {
-    return [ceilingHeightHandle()];
-}
-/**
- * Ceiling — Phase 5 batch kind, polygon-based. Structurally similar to
- * slab but with React-rendered hosted children + TSL shader materials +
- * named meshes that other systems poke (`getObjectByName('ceiling-grid')`).
- *
- * **Stage B intentionally skipped**: pure `def.geometry` extraction
- * would lose the React children rendering (hosted items) and the
- * named-mesh structure. Ceiling keeps `def.renderer` as its escape hatch
- * ("Opting out of a generic path" in wiki/architecture/node-definitions.md).
- * Renderer wraps the legacy CeilingRenderer; system wraps the legacy
- * CeilingSystem.
- *
- * **Stage C completed**: `def.floorplan` builder draws the ceiling
- * polygon as a dashed outline in floor plan; legacy `ceilingPolygons`
- * short-circuits to [] when ceiling is registered.
- */
-export const ceilingDefinition = {
-    kind: 'ceiling',
-    snapProfile: 'structural',
-    schemaVersion: 1,
-    schema: CeilingNode,
-    category: 'structure',
-    surfaceRole: 'ceiling',
-    extensions: {
-        [DRAFTING_SURFACE_EXTENSION_KEY]: {
-            kind: 'ceiling',
-            raycast: 'underside',
-        },
-        'pascal:editor/floorplan': {
-            selectionCounterparts: sameOutlineSurfaceCounterparts,
-        },
-        [PANEL_MODEL_EXTENSION]: ceilingPanelModel,
-    },
-    // Height-less on purpose: a new ceiling follows the level top until the
-    // user gives it an explicit custom height.
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        polygon: [],
-        holes: [],
-        holeMetadata: [],
-        autoFromWalls: false,
-    }),
-    capabilities: {
-        reveal: { phase: 'roof', style: 'settle', height: 0.08 },
-        revealOnEdit: ['polygon', 'holes', 'height'],
-        batchable: surfaceBatchable,
-        selectable: { hitVolume: 'bbox' },
-        surfaces: {
-            hosting: false,
-            top: {
-                height: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
-            },
-        },
-        duplicable: true,
-        deletable: true,
-        // Unified slot model: one paintable underside surface with a declared
-        // default, painted through the registry `capabilities.paint` dispatch.
-        slots: () => ceilingSlots(),
-        paint: ceilingPaint,
-    },
-    relations: {
-        hosts: ['item', 'procedural-item'],
-        cascadeDelete: 'descendants',
-    },
-    parametrics: ceilingParametrics,
-    handles: ceilingHandles,
-    measurement: {
-        features: (node) => polygonMeasurementFeatures({
-            featurePrefix: 'ceiling',
-            height: resolveCeilingHeight(node, useScene.getState().nodes),
-            label: 'Ceiling',
-            polygon: node.polygon,
-        }),
-    },
-    // Stage D: kind-owned placement tool. Multi-click polygon drawing
-    // with a vertical TSL-gradient connector + ground-shadow lines.
-    tool: () => import('./tool.js'),
-    // Stage D — all four ceiling drag-affordances live in this folder.
-    // 1:1 port of the legacy tools (scene.update per tick + history
-    // dance + preview fill/outline overlay on move).
-    affordanceTools: {
-        'boundary-edit': () => import('./boundary-editor.js'),
-        'hole-edit': () => import('./hole-editor.js'),
-        move: () => import('./move-tool.js'),
-    },
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 4,
-    },
-    floorplan: buildCeilingFloorplan,
-    floorplanDependsOnSiblings: true,
-    // 2D move handler — translates polygon by cursor delta from first
-    // pointer position. Mirror of slab; 3D `MoveCeilingTool` skips
-    // 2D-sourced grid events so they don't double-write on commit.
-    floorplanMoveTarget: ceilingFloorplanMoveTarget,
-    // Sister to `affordanceTools['boundary-edit']`. Same `polygon` field;
-    // SVG vertex handles dispatch to this affordance via the floor-plan
-    // registry layer.
-    floorplanAffordances: {
-        'move-vertex': ceilingMoveVertexAffordance,
-        'add-vertex': ceilingAddVertexAffordance,
-        'move-edge': ceilingMoveEdgeAffordance,
-        'delete-vertex': ceilingDeleteVertexAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Trace ceiling outline' },
-        { key: 'Enter', label: 'Finish ceiling', minDraftVertices: 3 },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Ceiling',
-        description: 'A polygon-bounded ceiling surface that hosts ceiling-mounted items.',
-        icon: { kind: 'url', src: '/icons/ceiling.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 40,
-    },
-    mcp: {
-        description: 'A polygon-bounded ceiling with optional cutout holes.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ceilingEditContribution } from './definition.edit.js';
+import { ceilingRenderDefinition } from './definition.render.js';
+export const ceilingDefinition = composeNodeDefinition(ceilingRenderDefinition, ceilingEditContribution);

package/dist/ceiling/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { CeilingNode } from './schema.js';
+export declare const ceilingRenderDefinition: NodeRenderDefinition<typeof CeilingNode> & {
+    kind: 'ceiling';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/ceiling/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,OAAO,WAAW,CAAC,GAAG;IAC/E,IAAI,EAAE,SAAS,CAAA;CAqEhB,CAAA"}

package/dist/ceiling/definition.render.js

@@ -0,0 +1,73 @@
+import { ceilingSlots, resolveCeilingHeight, useScene, } from '@pascal-app/core';
+import { surfaceBatchable } from '../shared/node-batch/batchable.js';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { buildCeilingFloorplan } from './floorplan.js';
+import { CeilingNode } from './schema.js';
+export const ceilingRenderDefinition = {
+    kind: 'ceiling',
+    schemaVersion: 1,
+    schema: CeilingNode,
+    category: 'structure',
+    surfaceRole: 'ceiling',
+    // Height-less on purpose: a new ceiling follows the level top until the
+    // user gives it an explicit custom height.
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        polygon: [],
+        holes: [],
+        holeMetadata: [],
+        autoFromWalls: false,
+    }),
+    capabilities: {
+        reveal: { phase: 'roof', style: 'settle', height: 0.08 },
+        revealOnEdit: ['polygon', 'holes', 'height'],
+        batchable: surfaceBatchable,
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            hosting: false,
+            top: {
+                height: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
+            },
+        },
+        duplicable: true,
+        deletable: true,
+        // Unified slot model: one paintable underside surface with a declared
+        // default, painted through the registry `capabilities.paint` dispatch.
+        slots: () => ceilingSlots(),
+    },
+    relations: {
+        hosts: ['item', 'procedural-item'],
+        cascadeDelete: 'descendants',
+    },
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'ceiling',
+            height: resolveCeilingHeight(node, useScene.getState().nodes),
+            label: 'Ceiling',
+            polygon: node.polygon,
+        }),
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 4,
+    },
+    floorplan: buildCeilingFloorplan,
+    presentation: {
+        label: 'Ceiling',
+        description: 'A polygon-bounded ceiling surface that hosts ceiling-mounted items.',
+        icon: { kind: 'url', src: '/icons/ceiling.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 40,
+    },
+    mcp: {
+        description: 'A polygon-bounded ceiling with optional cutout holes.',
+    },
+};

package/dist/ceiling/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { formatFixed, resolveCeilingHeight, usePascalI18n, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, exitCeilingEditToRoom, formatAreaLabel, formatLinearMeasurement, getAreaUnitLabel, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, ShapeChoice, SliderControl, setCeilingHoles, squareMetersToAreaUnit, startOpeningDraft, triggerSFX, useCeilingEditCeilingId, useCeilingEditSession, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { formatAreaLabel, formatFixed, formatLinearMeasurement, getAreaUnitLabel, resolveCeilingHeight, squareMetersToAreaUnit, usePascalI18n, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, exitCeilingEditToRoom, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, ShapeChoice, SliderControl, setCeilingHoles, startOpeningDraft, triggerSFX, useCeilingEditCeilingId, useCeilingEditSession, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Edit, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useRef } from 'react';