@pascal-app/nodes 0.1.1

package/dist/cabinet/tree-structure.d.ts

@@ -0,0 +1,13 @@
+import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+/** `def.tree.hidden` for cabinet runs: corner-derived legs disappear as rows
+ * (their modules resurface through `childIds` flattening). */
+export declare function cabinetTreeHidden(node: AnyNode, _nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): boolean;
+export declare function cabinetTreeLabel(node: AnyNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): string;
+/** `def.tree.childIds` for both cabinet kinds. */
+export declare function cabinetTreeChildIds(node: AnyNode, nodes: Readonly<Partial<Record<AnyNodeId, AnyNode>>>): AnyNodeId[];
+export declare function cabinetFloorplanAffectedIds(args: {
+    node: AnyNode;
+    nodes: Record<AnyNodeId, AnyNode>;
+    liveOverrides: Map<string, Record<string, unknown>>;
+}): readonly AnyNodeId[];
+//# sourceMappingURL=tree-structure.d.ts.map

package/dist/cabinet/tree-structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-structure.d.ts","sourceRoot":"","sources":["../../src/cabinet/tree-structure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAGV,MAAM,kBAAkB,CAAA;AA2FzB;8DAC8D;AAC9D,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GACpD,OAAO,CAET;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GACnD,MAAM,CAWR;AAED,kDAAkD;AAClD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,GACnD,SAAS,EAAE,CAuBb;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,SAAS,SAAS,EAAE,CAkCvB"}

package/dist/cabinet/tree-structure.js

@@ -0,0 +1,138 @@
+function cornerDerivedRunLink(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return null;
+    const value = metadata.cabinetCornerDerivedRun;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const role = value.role;
+    const side = value.side;
+    const sourceModuleId = value.sourceModuleId;
+    const sourceRunId = value.sourceRunId;
+    if ((role !== 'base-leg' && role !== 'wall-leg' && role !== 'bridge') ||
+        (side !== 'left' && side !== 'right') ||
+        typeof sourceModuleId !== 'string' ||
+        typeof sourceRunId !== 'string') {
+        return null;
+    }
+    return {
+        role,
+        side,
+        sourceModuleId: sourceModuleId,
+        sourceRunId: sourceRunId,
+    };
+}
+function isCabinetRun(node) {
+    return node?.type === 'cabinet';
+}
+function isCabinetModule(node) {
+    return node?.type === 'cabinet-module';
+}
+function cabinetModuleChildren(run, nodes) {
+    return (run.children ?? [])
+        .map((id) => nodes[id])
+        .filter((child) => child?.type === 'cabinet-module');
+}
+function childIdsOf(node) {
+    if (!node || typeof node !== 'object' || !('children' in node) || !Array.isArray(node.children)) {
+        return [];
+    }
+    return node.children;
+}
+function resolveCabinetRunChildIds(run, nodes) {
+    const resolved = [];
+    for (const childId of run.children ?? []) {
+        const child = nodes[childId];
+        if (isCabinetModule(child)) {
+            resolved.push(child.id);
+            continue;
+        }
+        if (!isCabinetRun(child))
+            continue;
+        const link = cornerDerivedRunLink(child.metadata);
+        if (link?.role === 'base-leg') {
+            resolved.push(...resolveCabinetRunChildIds(child, nodes));
+            continue;
+        }
+        if (link)
+            continue;
+        resolved.push(child.id);
+    }
+    return resolved;
+}
+/** `def.tree.hidden` for cabinet runs: corner-derived legs disappear as rows
+ * (their modules resurface through `childIds` flattening). */
+export function cabinetTreeHidden(node, _nodes) {
+    return isCabinetRun(node) && cornerDerivedRunLink(node.metadata) != null;
+}
+export function cabinetTreeLabel(node, nodes) {
+    if (node.name)
+        return node.name;
+    if (isCabinetRun(node)) {
+        const moduleCount = resolveCabinetRunChildIds(node, nodes).filter((childId) => {
+            const child = nodes[childId];
+            return child?.type === 'cabinet-module';
+        }).length;
+        return `Modular Cabinet (${moduleCount} module${moduleCount === 1 ? '' : 's'})`;
+    }
+    if (isCabinetModule(node))
+        return 'Cabinet Module';
+    return 'Node';
+}
+/** `def.tree.childIds` for both cabinet kinds. */
+export function cabinetTreeChildIds(node, nodes) {
+    if (isCabinetRun(node)) {
+        return resolveCabinetRunChildIds(node, nodes);
+    }
+    if (!isCabinetModule(node))
+        return [];
+    const resolved = [];
+    for (const childId of childIdsOf(node)) {
+        const child = nodes[childId];
+        if (isCabinetModule(child)) {
+            resolved.push(child.id);
+            continue;
+        }
+        if (!isCabinetRun(child))
+            continue;
+        const link = cornerDerivedRunLink(child.metadata);
+        if (link) {
+            resolved.push(...cabinetModuleChildren(child, nodes).map((module) => module.id));
+            continue;
+        }
+        resolved.push(child.id);
+    }
+    return resolved;
+}
+export function cabinetFloorplanAffectedIds(args) {
+    const { node, nodes, liveOverrides } = args;
+    const affected = new Set();
+    const visited = new Set();
+    const queue = [node.id];
+    while (queue.length > 0) {
+        const id = queue.pop();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        const current = nodes[id];
+        if (!isCabinetRun(current) && !isCabinetModule(current))
+            continue;
+        affected.add(id);
+        const parentIds = [
+            current.parentId,
+            liveOverrides.get(id)?.parentId,
+        ];
+        for (const parentId of parentIds) {
+            const parent = parentId ? nodes[parentId] : undefined;
+            if (parentId && (isCabinetRun(parent) || isCabinetModule(parent))) {
+                queue.push(parentId);
+            }
+        }
+        for (const childId of childIdsOf(current)) {
+            const child = nodes[childId];
+            if (isCabinetRun(child) || isCabinetModule(child)) {
+                queue.push(childId);
+            }
+        }
+    }
+    return Array.from(affected);
+}

package/dist/cabinet/wall-snap.d.ts

@@ -0,0 +1,66 @@
+import { type AnyNode, type AnyNodeId, type CabinetModuleNode } from '@pascal-app/core';
+import type { WallHit } from '../shared/wall-attach-target';
+export type CabinetWallSnapNeighbor = {
+    minX: number;
+    maxX: number;
+};
+export type CabinetWallSnapPlacement = {
+    position: [number, number, number];
+    yaw: number;
+    localX: number;
+    side: WallHit['side'];
+    snapReason: 'grid' | 'corner' | 'cabinet-edge';
+    guide: {
+        start: [number, number, number];
+        end: [number, number, number];
+    };
+};
+export declare function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }: {
+    hit: WallHit;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
+}): number;
+export declare function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds, parentLevelId, width, }: {
+    excludeIds?: readonly AnyNodeId[];
+    hit: WallHit;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
+    width: number;
+}): CabinetWallSnapNeighbor[];
+export declare function resolveCabinetWallSnapPlacement({ depth, gridStep, faceOffset, hit, neighbors, width, }: {
+    depth: number;
+    faceOffset?: number;
+    gridStep?: number;
+    hit: WallHit;
+    neighbors?: CabinetWallSnapNeighbor[];
+    width: number;
+}): CabinetWallSnapPlacement | null;
+/**
+ * Wall snap for a single dragged module, in its run's LOCAL frame — the
+ * frame `movable.parentFrame` kinds store `position` in. Converts the
+ * candidate to plan space, resolves the same flush-to-wall placement a run
+ * drag gets, and converts back. Snaps only when the module's world yaw
+ * already faces the wall (a module drag cannot rotate its run).
+ */
+export declare function resolveCabinetModuleWallSnapLocal({ candidateLocal, excludeIds, gridStep, module, nodes, parentLevelId, run, }: {
+    candidateLocal: [number, number, number];
+    excludeIds?: readonly AnyNodeId[];
+    gridStep?: number;
+    module: CabinetModuleNode;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
+    run: Extract<AnyNode, {
+        type: 'cabinet';
+    }>;
+}): [number, number, number] | null;
+export declare function resolveCabinetRunWallSnap({ cabinet, candidatePosition, excludeIds, gridStep, nodes, parentLevelId, }: {
+    cabinet: Extract<AnyNode, {
+        type: 'cabinet';
+    }>;
+    candidatePosition: [number, number, number];
+    excludeIds?: readonly AnyNodeId[];
+    gridStep?: number;
+    nodes: Record<AnyNodeId, AnyNode>;
+    parentLevelId: AnyNodeId;
+}): [number, number, number] | null;
+//# sourceMappingURL=wall-snap.d.ts.map

package/dist/cabinet/wall-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-snap.d.ts","sourceRoot":"","sources":["../../src/cabinet/wall-snap.ts"],"names":[],"mappings":"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"}

package/dist/cabinet/wall-snap.js

@@ -0,0 +1,255 @@
+import { calculateLevelMiters, getWallPlanFootprint, getWallThickness, } from '@pascal-app/core';
+import { findClosestWallInPlan, projectWallLocalPointToPlan } from '../shared/wall-attach-target';
+import { planToRunLocal, runLocalToPlan } from './run-layout';
+const EDGE_SNAP_THRESHOLD = 0.08;
+const FACE_MATCH_THRESHOLD = 0.12;
+const YAW_MATCH_THRESHOLD = 0.08;
+const WALL_FACE_EPSILON = 1e-5;
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+function angleDelta(a, b) {
+    return Math.atan2(Math.sin(a - b), Math.cos(a - b));
+}
+function snapLocalXToStops({ localX, neighbors, wallLength, width, }) {
+    if (wallLength <= width)
+        return { localX: wallLength / 2, reason: 'corner' };
+    const halfWidth = width / 2;
+    const stops = [
+        { value: 0, reason: 'corner' },
+        { value: wallLength, reason: 'corner' },
+    ];
+    for (const neighbor of neighbors) {
+        stops.push({ value: neighbor.minX, reason: 'cabinet-edge' }, { value: neighbor.maxX, reason: 'cabinet-edge' });
+    }
+    let best = null;
+    for (const movingStop of [localX - halfWidth, localX + halfWidth]) {
+        for (const stop of stops) {
+            const delta = stop.value - movingStop;
+            const candidateLocalX = localX + delta;
+            if (candidateLocalX < halfWidth || candidateLocalX > wallLength - halfWidth)
+                continue;
+            const distance = Math.abs(delta);
+            if (distance > EDGE_SNAP_THRESHOLD)
+                continue;
+            if (!best || distance < best.distance) {
+                best = { localX: candidateLocalX, distance, reason: stop.reason };
+            }
+        }
+    }
+    return best ? { localX: best.localX, reason: best.reason } : { localX, reason: 'grid' };
+}
+function cabinetRunWidthAndCenterOffset(cabinet, nodes) {
+    const modules = (cabinet.children ?? [])
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'cabinet-module');
+    if (modules.length === 0)
+        return { width: cabinet.width, centerOffset: 0 };
+    const minX = Math.min(...modules.map((module) => module.position[0] - module.width / 2));
+    const maxX = Math.max(...modules.map((module) => module.position[0] + module.width / 2));
+    return { width: Math.max(0.01, maxX - minX), centerOffset: (minX + maxX) / 2 };
+}
+export function resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId, }) {
+    const walls = Object.values(nodes).filter((node) => node?.type === 'wall' && node.parentId === parentLevelId);
+    if (walls.length === 0) {
+        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+    }
+    const miterData = calculateLevelMiters(walls);
+    const footprint = getWallPlanFootprint(hit.wall, miterData);
+    if (footprint.length < 3) {
+        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+    }
+    const frontNormal = [-hit.dirY, hit.dirX];
+    const localPoints = footprint.map((point) => {
+        const dx = point.x - hit.wall.start[0];
+        const dz = point.y - hit.wall.start[1];
+        return {
+            x: dx * hit.dirX + dz * hit.dirY,
+            z: dx * frontNormal[0] + dz * frontNormal[1],
+        };
+    });
+    const zIntersections = [];
+    for (let i = 0; i < localPoints.length; i += 1) {
+        const a = localPoints[i];
+        const b = localPoints[(i + 1) % localPoints.length];
+        const minX = Math.min(a.x, b.x);
+        const maxX = Math.max(a.x, b.x);
+        if (hit.localX < minX - WALL_FACE_EPSILON || hit.localX > maxX + WALL_FACE_EPSILON) {
+            continue;
+        }
+        const dx = b.x - a.x;
+        if (Math.abs(dx) <= WALL_FACE_EPSILON) {
+            if (Math.abs(hit.localX - a.x) <= WALL_FACE_EPSILON) {
+                zIntersections.push(a.z, b.z);
+            }
+            continue;
+        }
+        const t = (hit.localX - a.x) / dx;
+        if (t < -WALL_FACE_EPSILON || t > 1 + WALL_FACE_EPSILON)
+            continue;
+        zIntersections.push(a.z + (b.z - a.z) * t);
+    }
+    if (zIntersections.length === 0) {
+        return (hit.side === 'front' ? 1 : -1) * (getWallThickness(hit.wall) / 2);
+    }
+    return hit.side === 'front' ? Math.max(...zIntersections) : Math.min(...zIntersections);
+}
+export function collectCabinetWallSnapNeighbors({ hit, nodes, excludeIds = [], parentLevelId, width, }) {
+    const frontNormal = [-hit.dirY, hit.dirX];
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const yaw = Math.atan2(frontNormal[0] * normalScale, frontNormal[1] * normalScale);
+    const wallFaceOffset = getWallThickness(hit.wall) / 2;
+    const neighbors = [];
+    const excluded = new Set(excludeIds);
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'cabinet')
+            continue;
+        if (excluded.has(node.id))
+            continue;
+        if (node.parentId !== parentLevelId)
+            continue;
+        if (Math.abs(angleDelta(node.rotation, yaw)) > YAW_MATCH_THRESHOLD)
+            continue;
+        const run = cabinetRunWidthAndCenterOffset(node, nodes);
+        const localXAxis = [Math.cos(node.rotation), -Math.sin(node.rotation)];
+        const centerX = node.position[0] + localXAxis[0] * run.centerOffset;
+        const centerZ = node.position[2] + localXAxis[1] * run.centerOffset;
+        const fromStartX = centerX - hit.wall.start[0];
+        const fromStartZ = centerZ - hit.wall.start[1];
+        const localX = fromStartX * hit.dirX + fromStartZ * hit.dirY;
+        const perp = fromStartX * frontNormal[0] + fromStartZ * frontNormal[1];
+        const expectedPerp = normalScale * (wallFaceOffset + node.depth / 2);
+        if (Math.abs(perp - expectedPerp) > FACE_MATCH_THRESHOLD)
+            continue;
+        const minX = localX - run.width / 2;
+        const maxX = localX + run.width / 2;
+        if (maxX < width / 2 || minX > hit.wallLength - width / 2)
+            continue;
+        neighbors.push({ minX, maxX });
+    }
+    return neighbors;
+}
+export function resolveCabinetWallSnapPlacement({ depth, gridStep = 0, faceOffset, hit, neighbors = [], width, }) {
+    if (hit.wallLength <= 1e-6)
+        return null;
+    const halfWidth = width / 2;
+    const snappedLocalX = snap(hit.localX, gridStep);
+    const clampedLocalX = hit.wallLength > width
+        ? Math.min(hit.wallLength - halfWidth, Math.max(halfWidth, snappedLocalX))
+        : hit.wallLength / 2;
+    const snapped = snapLocalXToStops({
+        localX: clampedLocalX,
+        neighbors,
+        wallLength: hit.wallLength,
+        width,
+    });
+    const localX = snapped.localX;
+    const centerline = projectWallLocalPointToPlan(hit.wall, localX);
+    const frontNormal = [-hit.dirY, hit.dirX];
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const normal = [frontNormal[0] * normalScale, frontNormal[1] * normalScale];
+    const resolvedFaceOffset = faceOffset ?? (normalScale * getWallThickness(hit.wall)) / 2;
+    const cabinetCenterOffset = resolvedFaceOffset + normalScale * (depth / 2);
+    const guideOffset = resolvedFaceOffset;
+    const guideStart = projectWallLocalPointToPlan(hit.wall, Math.max(0, localX - halfWidth), guideOffset);
+    const guideEnd = projectWallLocalPointToPlan(hit.wall, Math.min(hit.wallLength, localX + halfWidth), guideOffset);
+    return {
+        position: [
+            centerline[0] + frontNormal[0] * cabinetCenterOffset,
+            0,
+            centerline[1] + frontNormal[1] * cabinetCenterOffset,
+        ],
+        yaw: Math.atan2(normal[0], normal[1]),
+        localX,
+        side: hit.side,
+        snapReason: snapped.reason,
+        guide: {
+            start: [guideStart[0], 0.025, guideStart[1]],
+            end: [guideEnd[0], 0.025, guideEnd[1]],
+        },
+    };
+}
+/**
+ * Wall snap for a single dragged module, in its run's LOCAL frame — the
+ * frame `movable.parentFrame` kinds store `position` in. Converts the
+ * candidate to plan space, resolves the same flush-to-wall placement a run
+ * drag gets, and converts back. Snaps only when the module's world yaw
+ * already faces the wall (a module drag cannot rotate its run).
+ */
+export function resolveCabinetModuleWallSnapLocal({ candidateLocal, excludeIds = [], gridStep = 0, module, nodes, parentLevelId, run, }) {
+    const planCenter = runLocalToPlan(run, candidateLocal);
+    const hit = findClosestWallInPlan([planCenter[0], planCenter[2]], nodes, parentLevelId);
+    if (!hit)
+        return null;
+    if (excludeIds.includes(hit.wall.id))
+        return null;
+    const faceOffset = resolveCabinetWallFaceOffset({ hit, nodes, parentLevelId });
+    const placement = resolveCabinetWallSnapPlacement({
+        depth: module.depth,
+        faceOffset,
+        gridStep,
+        hit,
+        neighbors: collectCabinetWallSnapNeighbors({
+            hit,
+            nodes,
+            // The moving module's own run must not offer edge stops — its span
+            // still includes the module's pre-drag position.
+            excludeIds: [...excludeIds, run.id],
+            parentLevelId,
+            width: module.width,
+        }),
+        width: module.width,
+    });
+    if (!placement)
+        return null;
+    const worldYaw = run.rotation + module.rotation;
+    if (Math.abs(angleDelta(worldYaw, placement.yaw)) > YAW_MATCH_THRESHOLD)
+        return null;
+    return planToRunLocal(run, placement.position[0], candidateLocal[1], placement.position[2]);
+}
+export function resolveCabinetRunWallSnap({ cabinet, candidatePosition, excludeIds = [], gridStep = 0, nodes, parentLevelId, }) {
+    const run = cabinetRunWidthAndCenterOffset(cabinet, nodes);
+    const axisX = Math.cos(cabinet.rotation);
+    const axisZ = -Math.sin(cabinet.rotation);
+    const footprintCenter = [
+        candidatePosition[0] + axisX * run.centerOffset,
+        candidatePosition[2] + axisZ * run.centerOffset,
+    ];
+    const hit = findClosestWallInPlan(footprintCenter, nodes, parentLevelId);
+    if (!hit)
+        return null;
+    // A wall moving with the same group (whole-room drag) still sits at its
+    // pre-drag position in `nodes` — snapping to it would tear the group apart.
+    if (excludeIds.includes(hit.wall.id))
+        return null;
+    const faceOffset = resolveCabinetWallFaceOffset({
+        hit,
+        nodes,
+        parentLevelId,
+    });
+    const placement = resolveCabinetWallSnapPlacement({
+        depth: cabinet.depth,
+        faceOffset,
+        gridStep,
+        hit,
+        neighbors: collectCabinetWallSnapNeighbors({
+            hit,
+            nodes,
+            excludeIds,
+            parentLevelId,
+            width: run.width,
+        }),
+        width: run.width,
+    });
+    if (!placement)
+        return null;
+    if (Math.abs(angleDelta(cabinet.rotation, placement.yaw)) > YAW_MATCH_THRESHOLD)
+        return null;
+    return [
+        placement.position[0] - Math.cos(placement.yaw) * run.centerOffset,
+        candidatePosition[1],
+        placement.position[2] + Math.sin(placement.yaw) * run.centerOffset,
+    ];
+}

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

@@ -0,0 +1,17 @@
+import { type CeilingNode } from '@pascal-app/core';
+/**
+ * Phase 5 Stage D — ceiling boundary editor (registry-driven).
+ *
+ * Thin wrapper around the shared `<PolygonEditor>` (same shape as
+ * slab's boundary-editor). Activates when a ceiling is selected in
+ * structure/select mode and no hole edit is in progress.
+ *
+ * Drag flow mirrors slab: `onPolygonPreview` pushes the in-flight
+ * polygon to `useLiveNodeOverrides` so the ceiling mesh rebuilds at
+ * pointer rate; `onPolygonChange` is the single commit on release.
+ */
+export declare const CeilingBoundaryEditor: React.FC<{
+    ceilingId: CeilingNode['id'];
+}>;
+export default CeilingBoundaryEditor;
+//# sourceMappingURL=boundary-editor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boundary-editor.d.ts","sourceRoot":"","sources":["../../src/ceiling/boundary-editor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAkD,MAAM,kBAAkB,CAAA;AAanG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAAE,CAwJ5E,CAAA;AAED,eAAe,qBAAqB,CAAA"}

package/dist/ceiling/boundary-editor.js

@@ -0,0 +1,118 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolveLevelId, useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { boundaryReshapeScope, clearCeilingSnapFeedback, PolygonEditor, resolveCeilingPlanPointSnap, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+/**
+ * Phase 5 Stage D — ceiling boundary editor (registry-driven).
+ *
+ * Thin wrapper around the shared `<PolygonEditor>` (same shape as
+ * slab's boundary-editor). Activates when a ceiling is selected in
+ * structure/select mode and no hole edit is in progress.
+ *
+ * Drag flow mirrors slab: `onPolygonPreview` pushes the in-flight
+ * polygon to `useLiveNodeOverrides` so the ceiling mesh rebuilds at
+ * pointer rate; `onPolygonChange` is the single commit on release.
+ */
+export const CeilingBoundaryEditor = ({ ceilingId, }) => {
+    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 setHoveredId = useViewer((s) => s.setHoveredId);
+    const ownsCeilingHoverRef = useRef(false);
+    const ownsPolygonPreviewRef = useRef(false);
+    const liveOverride = useLiveNodeOverrides((state) => {
+        if (ownsPolygonPreviewRef.current)
+            return null;
+        return state.overrides.get(ceilingId);
+    });
+    const ceiling = ceilingNode?.type === 'ceiling' ? ceilingNode : null;
+    const effectiveCeiling = useMemo(() => (ceiling && liveOverride ? { ...ceiling, ...liveOverride } : ceiling), [ceiling, liveOverride]);
+    const ceilingLevelId = effectiveCeiling
+        ? resolveLevelId(effectiveCeiling, useScene.getState().nodes)
+        : null;
+    const handlePolygonChange = useCallback((newPolygon) => {
+        clearCeilingSnapFeedback();
+        updateNode(ceilingId, { polygon: newPolygon });
+        setSelection({ selectedIds: [ceilingId] });
+    }, [ceilingId, updateNode, setSelection]);
+    const handlePolygonPreview = useCallback((preview) => {
+        if (preview) {
+            ownsPolygonPreviewRef.current = true;
+            useLiveNodeOverrides.getState().set(ceilingId, {
+                polygon: preview.map(([x, z]) => [x, z]),
+            });
+        }
+        else {
+            useLiveNodeOverrides.getState().clear(ceilingId);
+            ownsPolygonPreviewRef.current = false;
+        }
+        markDirty(ceilingId);
+    }, [ceilingId, markDirty]);
+    const setCeilingHandleHover = useCallback((active) => {
+        if (active) {
+            ownsCeilingHoverRef.current = true;
+            setHoveredId(ceilingId);
+            return;
+        }
+        if (ownsCeilingHoverRef.current && useViewer.getState().hoveredId === ceilingId) {
+            setHoveredId(null);
+        }
+        ownsCeilingHoverRef.current = false;
+    }, [ceilingId, setHoveredId]);
+    const handleHandleHoverChange = useCallback((index) => {
+        setCeilingHandleHover(index !== null);
+    }, [setCeilingHandleHover]);
+    const handleDragStateChange = useCallback((isDragging) => {
+        // A vertex/edge drag is a `boundary` reshape — drive the snapping HUD
+        // (no-angle 'polygon' set) and keep the idle select hints off-screen.
+        const scope = useInteractionScope.getState();
+        if (isDragging) {
+            scope.begin(boundaryReshapeScope(ceilingId));
+        }
+        else {
+            scope.endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
+            ownsPolygonPreviewRef.current = false;
+            clearCeilingSnapFeedback();
+        }
+        setCeilingHandleHover(isDragging);
+    }, [ceilingId, setCeilingHandleHover]);
+    const handlePolygonEditorDragCommit = useCallback(() => {
+        triggerSFX('sfx:item-place');
+        clearCeilingSnapFeedback();
+    }, []);
+    const handlePolygonEditorDragStart = useCallback(() => {
+        ownsPolygonPreviewRef.current = true;
+        triggerSFX('sfx:item-pick');
+    }, []);
+    const handlePolygonEditorBeforeVertexDrag = useCallback(() => {
+        ownsPolygonPreviewRef.current = true;
+    }, []);
+    const resolvePolygonEditorPlanPoint = useCallback((context) => resolveCeilingPlanPointSnap({
+        rawPoint: context.rawPoint,
+        fallbackPoint: context.gridPoint,
+        levelId: ceilingLevelId,
+        excludeId: ceilingId,
+    }).point, [ceilingId, ceilingLevelId]);
+    useEffect(() => {
+        return () => {
+            clearCeilingSnapFeedback();
+            useLiveNodeOverrides.getState().clear(ceilingId);
+            useScene.getState().markDirty(ceilingId);
+            useInteractionScope
+                .getState()
+                .endIf((s) => s.kind === 'reshaping' && s.reshape === 'boundary');
+            ownsPolygonPreviewRef.current = false;
+            if (ownsCeilingHoverRef.current && useViewer.getState().hoveredId === ceilingId) {
+                useViewer.getState().setHoveredId(null);
+            }
+            ownsCeilingHoverRef.current = false;
+        };
+    }, [ceilingId]);
+    if (!effectiveCeiling?.polygon || effectiveCeiling.polygon.length < 3)
+        return null;
+    return (_jsx(PolygonEditor, { allowEdgeMove: true, color: "#d4d4d4", highlightConnectedHandles: true, levelId: ceilingLevelId ?? undefined, minVertices: 3, onBeforeVertexDrag: handlePolygonEditorBeforeVertexDrag, onDragCommit: handlePolygonEditorDragCommit, onDragStart: handlePolygonEditorDragStart, onDragStateChange: handleDragStateChange, onEdgeHoverChange: handleHandleHoverChange, onMidpointHoverChange: handleHandleHoverChange, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, onVertexHoverChange: handleHandleHoverChange, polygon: effectiveCeiling.polygon, resolvePlanPoint: resolvePolygonEditorPlanPoint, surfaceHeight: effectiveCeiling.height ?? 2.5 }));
+};
+export default CeilingBoundaryEditor;

package/dist/ceiling/definition.d.ts

@@ -0,0 +1,20 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { CeilingNode } from './schema';
+/**
+ * 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 declare const ceilingDefinition: NodeDefinition<typeof CeilingNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/ceiling/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAiDtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAwGhE,CAAA"}