@pascal-app/nodes 0.1.1

package/dist/ceiling/definition.js

@@ -0,0 +1,161 @@
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { buildCeilingFloorplan } from './floorplan';
+import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances';
+import { ceilingFloorplanMoveTarget } from './floorplan-move';
+import { ceilingPaint } from './paint';
+import { ceilingParametrics } from './parametrics';
+import { CeilingNode } from './schema';
+import { ceilingSlots } from './slots';
+const HEIGHT_HANDLE_OFFSET = 0.22;
+const MIN_CEILING_HEIGHT = 0.5;
+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];
+}
+// 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.
+//
+// The placement Y is in *mesh-local* coords. CeilingSystem already
+// parks `mesh.position.y = ceiling.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: MIN_CEILING_HEIGHT,
+        currentValue: (n) => n.height ?? 2.5,
+        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 the custom
+ * escape hatch (per plans/editor-node-registry.md "custom-behavior
+ * escape hatch"). 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',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        polygon: [],
+        holes: [],
+        holeMetadata: [],
+        height: 2.5,
+        autoFromWalls: false,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            top: { height: (n) => n.height },
+        },
+        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'],
+        cascadeDelete: 'descendants',
+    },
+    parametrics: ceilingParametrics,
+    handles: ceilingHandles,
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'ceiling',
+            height: node.height,
+            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'),
+    // 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'),
+        'hole-edit': () => import('./hole-editor'),
+        move: () => import('./move-tool'),
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 4,
+    },
+    floorplan: buildCeilingFloorplan,
+    // 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.',
+    },
+};

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

@@ -0,0 +1,181 @@
+export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `ceiling_${string}`;
+    type: "ceiling";
+    children: `item_${string}`[];
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    height: 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 ceilingAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `ceiling_${string}`;
+    type: "ceiling";
+    children: `item_${string}`[];
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    height: 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 ceilingMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `ceiling_${string}`;
+    type: "ceiling";
+    children: `item_${string}`[];
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    height: 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 ceilingDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: import("zod").JSONType;
+    id: `ceiling_${string}`;
+    type: "ceiling";
+    children: `item_${string}`[];
+    polygon: [number, number][];
+    holes: [number, number][][];
+    holeMetadata: {
+        source: "elevator" | "stair" | "manual";
+        stairId?: string | undefined;
+        elevatorId?: string | undefined;
+    }[];
+    height: 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/ceiling/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-affordances.ts"],"names":[],"mappings":"AAqCA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvC,CAAA;AACD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAA;AACD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrC,CAAA;AACD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGzC,CAAA"}

package/dist/ceiling/floorplan-affordances.js

@@ -0,0 +1,28 @@
+import { resolveLevelId } from '@pascal-app/core';
+import { resolveCeilingPlanPointSnap } from '@pascal-app/editor';
+import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance';
+/**
+ * 2D affordances for ceiling. Same four operations as slab
+ * (`move-vertex`, `add-vertex`, `move-edge`, `delete-vertex`), each accepting an
+ * optional `holeIndex`. See `slab/floorplan-affordances.ts` for the
+ * full contract.
+ */
+const ceilingSnapOptions = {
+    boundaryCommitData: { autoFromWalls: false },
+    resolvePlanPoint({ node, nodes, rawPoint, fallbackPoint, }) {
+        const sceneNodes = nodes;
+        return resolveCeilingPlanPointSnap({
+            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;
+    },
+};
+export const ceilingMoveVertexAffordance = createPolygonVertexAffordance('ceiling', ceilingSnapOptions);
+export const ceilingAddVertexAffordance = createPolygonAddVertexAffordance('ceiling', ceilingSnapOptions);
+export const ceilingMoveEdgeAffordance = createPolygonMoveEdgeAffordance('ceiling', ceilingSnapOptions);
+export const ceilingDeleteVertexAffordance = createPolygonDeleteVertexAffordance('ceiling', ceilingSnapOptions);

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

@@ -0,0 +1,12 @@
+import type { CeilingNode, FloorplanMoveTarget } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for ceiling. Delegates to the shared polygon
+ * centroid-pivot mover (same pivot semantics as slab / items). See
+ * `shared/polygon-centroid-move.ts` for the rationale.
+ *
+ * `meshY = height − 0.01`: `CeilingSystem` parks the ceiling group at that Y
+ * on rebuild, so mirroring it during the drag avoids a vertical teleport in
+ * split view.
+ */
+export declare const ceilingFloorplanMoveTarget: FloorplanMoveTarget<CeilingNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAGxE;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,WAAW,CAMpE,CAAA"}

package/dist/ceiling/floorplan-move.js

@@ -0,0 +1,16 @@
+import { createPolygonCentroidMoveTarget } from '../shared/polygon-centroid-move';
+/**
+ * 2D floor-plan move handler for ceiling. Delegates to the shared polygon
+ * centroid-pivot mover (same pivot semantics as slab / items). See
+ * `shared/polygon-centroid-move.ts` for the rationale.
+ *
+ * `meshY = height − 0.01`: `CeilingSystem` parks the ceiling group at that Y
+ * on rebuild, so mirroring it during the drag avoids a vertical teleport in
+ * split view.
+ */
+export const ceilingFloorplanMoveTarget = ({ node, nodes }) => createPolygonCentroidMoveTarget({
+    node,
+    nodes,
+    meshY: (node.height ?? 2.5) - 0.01,
+    extraCommitData: node.autoFromWalls ? { autoFromWalls: false } : undefined,
+});

package/dist/ceiling/floorplan.d.ts

@@ -0,0 +1,9 @@
+import type { CeilingNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for ceiling. Dashed boundary (ceilings sit
+ * above the slab); when selected, mounts the same boundary editor as
+ * slab — vertex + midpoint + edge handles on the outer ring AND every
+ * hole, with `holeIndex` carried in the handle payloads.
+ */
+export declare function buildCeilingFloorplan(node: CeilingNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/ceiling/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B"}

package/dist/ceiling/floorplan.js

@@ -0,0 +1,90 @@
+/**
+ * Stage C floor-plan builder for ceiling. Dashed boundary (ceilings sit
+ * above the slab); when selected, mounts the same boundary editor as
+ * slab — vertex + midpoint + edge handles on the outer ring AND every
+ * hole, with `holeIndex` carried in the handle payloads.
+ */
+export function buildCeilingFloorplan(node, ctx) {
+    const polygon = node.polygon;
+    if (!polygon || polygon.length < 3)
+        return null;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const outer = polygon.map(([x, z]) => [x, z]);
+    const ring = (points) => {
+        const [first, ...rest] = points;
+        if (!first)
+            return '';
+        return [`M ${first[0]} ${first[1]}`, ...rest.map(([x, y]) => `L ${x} ${y}`), 'Z'].join(' ');
+    };
+    const segments = [ring(outer)];
+    const holes = node.holes ?? [];
+    for (const hole of holes) {
+        if (hole.length < 3)
+            continue;
+        segments.push(ring(hole.map(([x, z]) => [x, z])));
+    }
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#94a3b8';
+    const children = [
+        {
+            kind: 'path',
+            d: segments.join(' '),
+            fill: 'none',
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.04 : 0.03,
+            strokeDasharray: '0.15 0.1',
+            opacity: showSelectedChrome ? 0.95 : 0.7,
+        },
+    ];
+    if (isSelected) {
+        appendRingEditor(children, polygon, undefined);
+        holes.forEach((hole, holeIndex) => {
+            if (hole.length >= 3)
+                appendRingEditor(children, hole, holeIndex);
+        });
+    }
+    return { kind: 'group', children };
+}
+/**
+ * Same boundary editor as slab — see `nodes/src/slab/floorplan.ts` for
+ * the contract. The kinds differ only in their fill / stroke chrome;
+ * the editor primitives are identical.
+ */
+function appendRingEditor(children, ring, holeIndex) {
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        children.push({
+            kind: 'edge-handle',
+            x1: a[0],
+            y1: a[1],
+            x2: b[0],
+            y2: b[1],
+            affordance: 'move-edge',
+            payload: { holeIndex, edgeIndex: i },
+        });
+    }
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i];
+        const b = ring[(i + 1) % ring.length];
+        children.push({
+            kind: 'midpoint-handle',
+            point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+            affordance: 'add-vertex',
+            payload: { holeIndex, edgeIndex: i },
+        });
+    }
+    for (let i = 0; i < ring.length; i++) {
+        const [x, z] = ring[i];
+        children.push({
+            kind: 'endpoint-handle',
+            point: [x, z],
+            state: 'idle',
+            affordance: 'move-vertex',
+            payload: { holeIndex, vertexIndex: i },
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import { type CeilingNode } from '@pascal-app/core';
+/**
+ * Phase 5 Stage D — ceiling hole editor (registry-driven).
+ */
+export declare const CeilingHoleEditor: React.FC<{
+    ceilingId: CeilingNode['id'];
+    holeIndex: number;
+}>;
+export default CeilingHoleEditor;
+//# sourceMappingURL=hole-editor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hole-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/hole-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAkD,MAAM,kBAAkB,CAAA;AAKnG;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC;IACvC,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;CAClB,CAwDA,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/ceiling/hole-editor.js

@@ -0,0 +1,45 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolveLevelId, useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { PolygonEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect } from 'react';
+/**
+ * Phase 5 Stage D — ceiling hole editor (registry-driven).
+ */
+export const CeilingHoleEditor = ({ ceilingId, holeIndex }) => {
+    const ceilingNode = useScene((s) => s.nodes[ceilingId]);
+    const updateNode = useScene((s) => s.updateNode);
+    const markDirty = useScene((s) => s.markDirty);
+    const setSelection = useViewer((s) => s.setSelection);
+    const ceiling = ceilingNode?.type === 'ceiling' ? ceilingNode : null;
+    const holes = ceiling?.holes || [];
+    const hole = holes[holeIndex];
+    const handlePolygonChange = useCallback((newPolygon) => {
+        const updatedHoles = [...holes];
+        updatedHoles[holeIndex] = newPolygon;
+        updateNode(ceilingId, { holes: updatedHoles });
+        setSelection({ selectedIds: [ceilingId] });
+    }, [ceilingId, holeIndex, holes, updateNode, setSelection]);
+    const handlePolygonPreview = useCallback((preview) => {
+        if (preview) {
+            const updatedHoles = [...holes];
+            updatedHoles[holeIndex] = preview.map(([x, z]) => [x, z]);
+            useLiveNodeOverrides.getState().set(ceilingId, { holes: updatedHoles });
+        }
+        else {
+            useLiveNodeOverrides.getState().clear(ceilingId);
+        }
+        markDirty(ceilingId);
+    }, [ceilingId, holeIndex, holes, markDirty]);
+    useEffect(() => {
+        return () => {
+            useLiveNodeOverrides.getState().clear(ceilingId);
+            useScene.getState().markDirty(ceilingId);
+        };
+    }, [ceilingId]);
+    if (!(ceiling && hole) || hole.length < 3)
+        return null;
+    return (_jsx(PolygonEditor, { allowEdgeMove: true, allowPolygonMove: true, color: "#ef4444", levelId: resolveLevelId(ceiling, useScene.getState().nodes), minVertices: 3, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, polygon: hole, surfaceHeight: ceiling.height ?? 2.5 }));
+};
+export default CeilingHoleEditor;

package/dist/ceiling/index.d.ts

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

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

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

package/dist/ceiling/index.js

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

package/dist/ceiling/materials.d.ts

@@ -0,0 +1,15 @@
+import { type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+export type CeilingMaterials = {
+    topMaterial: MeshBasicNodeMaterial;
+    bottomMaterial: MeshBasicNodeMaterial;
+};
+export declare function getCeilingMaterials(color?: string): CeilingMaterials;
+/**
+ * Resolve a slot `MaterialRef` to a flat colour for the ceiling surface.
+ * `library:` refs use the catalog preset's base colour; `scene:` refs use the
+ * stored material's colour. Returns null for a dangling / unparseable ref so
+ * the caller falls back to its default.
+ */
+export declare function ceilingColorFromRef(ref: string | undefined, sceneMaterials: Record<SceneMaterialId, SceneMaterial> | undefined): string | null;
+//# sourceMappingURL=materials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/ceiling/materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAuB,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAoBzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,cAAc,EAAE,qBAAqB,CAAA;CACtC,CAAA;AAsBD,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,gBAAgB,CAMvE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,GACjE,MAAM,GAAG,IAAI,CASf"}

package/dist/ceiling/materials.js

@@ -0,0 +1,61 @@
+import { getMaterialPresetByRef, parseMaterialRef, resolveMaterial, } from '@pascal-app/core';
+import { float, mix, positionWorld, smoothstep } from 'three/tsl';
+import { BackSide, FrontSide, MeshBasicNodeMaterial } from 'three/webgpu';
+/**
+ * Ceiling material builders, shared by the renderer (mesh appearance) and the
+ * paint capability (hover preview). A ceiling is a flat tinted surface: the
+ * underside (`bottom`, seen from inside the room, `BackSide`) is opaque, while
+ * the `top` carries a transparent TSL grid overlay used while placing /
+ * selecting ceiling-hosted items. Both derive from a single colour, so slot
+ * painting resolves a colour and rebuilds these — it never applies a PBR map.
+ */
+const gridScale = 5;
+const gridX = positionWorld.x.mul(gridScale).fract();
+const gridY = positionWorld.z.mul(gridScale).fract();
+const lineWidth = 0.05;
+const lineX = smoothstep(lineWidth, 0, gridX).add(smoothstep(1.0 - lineWidth, 1.0, gridX));
+const lineY = smoothstep(lineWidth, 0, gridY).add(smoothstep(1.0 - lineWidth, 1.0, gridY));
+const gridPattern = lineX.max(lineY);
+const gridOpacity = mix(float(0.2), float(0.6), gridPattern);
+function createCeilingMaterials(color = '#999999') {
+    const topMaterial = new MeshBasicNodeMaterial({
+        color,
+        transparent: true,
+        depthWrite: false,
+        side: FrontSide,
+    });
+    topMaterial.opacityNode = gridOpacity;
+    const bottomMaterial = new MeshBasicNodeMaterial({
+        color,
+        transparent: true,
+        side: BackSide,
+    });
+    return { topMaterial, bottomMaterial };
+}
+const ceilingMaterialCache = new Map();
+export function getCeilingMaterials(color = '#999999') {
+    const cached = ceilingMaterialCache.get(color);
+    if (cached)
+        return cached;
+    const materials = createCeilingMaterials(color);
+    ceilingMaterialCache.set(color, materials);
+    return materials;
+}
+/**
+ * Resolve a slot `MaterialRef` to a flat colour for the ceiling surface.
+ * `library:` refs use the catalog preset's base colour; `scene:` refs use the
+ * stored material's colour. Returns null for a dangling / unparseable ref so
+ * the caller falls back to its default.
+ */
+export function ceilingColorFromRef(ref, sceneMaterials) {
+    const parsed = parseMaterialRef(ref);
+    if (!parsed)
+        return null;
+    if (parsed.kind === 'library') {
+        return getMaterialPresetByRef(ref)?.mapProperties.color ?? null;
+    }
+    const sceneMaterial = sceneMaterials?.[parsed.id];
+    if (!sceneMaterial)
+        return null;
+    return resolveMaterial(sceneMaterial.material).color ?? null;
+}