@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/definition.js

@@ -1,22 +1,21 @@
-import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, } from '@pascal-app/editor';
-import { buildWallContextualDimensions } from './contextual-dimensions';
-import { hasWallCurveBlockingChildren } from './curve-eligibility';
-import { useWallDrawingMode } from './drawing-mode';
-import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
-import { wallCurveAffordance, wallMoveEndpointAffordance, wallThicknessAffordance, } from './floorplan-affordances';
-import { wallFloorplanMoveTarget } from './floorplan-move';
-import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
-import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
-import { wallPaint } from './paint';
-import { wallSettings } from './panel-model';
-import { wallParametrics } from './parametrics';
-import { wallQuickMeasurement } from './quick-measurement';
-import { WallNode } from './schema';
-import { wallSlots } from './slots';
-import { WALL_SPLIT_MAX_CUTS } from './split-preview';
-import { setWallSplitCuts } from './split-session';
-import { useWallSplit } from './split-store';
+import { DEFAULT_WALL_THICKNESS, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, wallSlots, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY, getWallDrawVariant, PANEL_MODEL_EXTENSION, useEditor, } from '@pascal-app/editor';
+import { buildWallContextualDimensions } from './contextual-dimensions.js';
+import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
+import { wallSeenFromOutside } from './exterior.js';
+import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan.js';
+import { wallCurveAffordance, wallMoveEndpointAffordance, wallThicknessAffordance, } from './floorplan-affordances.js';
+import { wallFloorplanMoveTarget } from './floorplan-move.js';
+import { wallFloorplanSiblingOverrides } from './floorplan-overrides.js';
+import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement.js';
+import { wallPaint } from './paint.js';
+import { wallReferenceModel, wallSettings } from './panel-model.js';
+import { wallParametrics } from './parametrics.js';
+import { wallQuickMeasurement } from './quick-measurement.js';
+import { WallNode } from './schema.js';
+import { WALL_SPLIT_MAX_CUTS } from './split-preview.js';
+import { setWallSplitCuts } from './split-session.js';
+import { useWallSplit } from './split-store.js';
 /**
  * Wall — the Phase 3 stress test of the registry-driven node model.
  *
@@ -33,16 +32,35 @@ import { useWallSplit } from './split-store';
  *   wall is registered.
  */
 const SPLIT_CUT_COUNTS = Array.from({ length: WALL_SPLIT_MAX_CUTS }, (_, index) => String(index + 1));
+/** Show a tool hint only while the wall tool draws this Rooms variant. */
+const whenWallVariant = (variant) => ({
+    subscribe: (onChange) => useEditor.subscribe(onChange),
+    value: () => getWallDrawVariant() === variant,
+});
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 9,
+    schemaVersion: 10,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
     extensions: {
         [PANEL_MODEL_EXTENSION]: {
             rows: ({ node, nodes, update }) => wallSettings(node, nodes, update),
+            multiControls: ({ selection, nodes }) => {
+                const reference = wallReferenceModel(selection, nodes);
+                return [
+                    {
+                        id: 'wall-reference',
+                        kind: 'segmented',
+                        section: 'Dimensions',
+                        label: 'Reference',
+                        options: reference.options,
+                        value: reference.value,
+                        onChange: (value) => reference.apply(value),
+                    },
+                ];
+            },
         },
         [DRAFTING_SURFACE_EXTENSION_KEY]: {
             kind: 'wall',
@@ -64,11 +82,11 @@ export const wallDefinition = {
             },
         },
         'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool'),
-            reshapeLayers: { split: () => import('./split-floorplan-layer') },
+            tool: () => import('./floorplan-tool.js'),
+            reshapeLayers: { split: () => import('./split-floorplan-layer.js') },
             contextualDimensions: buildWallContextualDimensions,
             actionMenu: {
-                actions: () => import('./actions'),
+                actions: () => import('./actions.js'),
                 canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
                     const child = nodes[childId];
                     return child ? [child] : [];
@@ -88,6 +106,10 @@ export const wallDefinition = {
         backSide: 'unknown',
     }),
     capabilities: {
+        reveal: { phase: 'structure', style: 'rise' },
+        exterior: wallSeenFromOutside,
+        revealLayout: { line: (node) => (node.type === 'wall' ? [node.start, node.end] : null) },
+        revealOnEdit: ['start', 'end', 'curveOffset', 'height', 'thickness', 'wallType', 'curtainWall'],
         // Wall move is bespoke (endpoint drag, linked-wall corner cascade,
         // ALT-detach). Omitting `movable` keeps the legacy MoveWallTool via
         // capability-driven dispatch.
@@ -115,6 +137,13 @@ export const wallDefinition = {
         // Paint still writes the legacy inline fields for base faces via
         // `wallPaint`; migrating those fully into `node.slots` is a later step.
         slots: (node) => wallSlots(node),
+        // F2 layers stack from the front face (or the exterior with
+        // `face: 'exterior'`); `thickness` holds their sum.
+        assembly: {
+            reference: 'front',
+            measure: 'normal',
+            body: (node) => node.thickness ?? DEFAULT_WALL_THICKNESS,
+        },
     },
     relations: {
         hosts: ['door', 'window', 'item', 'lean-to-extension'],
@@ -132,20 +161,20 @@ export const wallDefinition = {
     // `planWallMoveJunctions`, ALT-detach, bridge wall previews,
     // auto-slab live preview, history dances). Placement is wired via
     // `def.tool`.
-    tool: () => import('./tool'),
-    preview: () => import('./preview'),
+    tool: () => import('./tool.js'),
+    preview: () => import('./preview.js'),
     affordanceTools: {
-        curve: () => import('./curve-tool'),
-        'move-endpoint': () => import('./move-endpoint-tool'),
-        move: () => import('./move-tool'),
-        split: () => import('./split-tool'),
+        curve: () => import('./curve-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+        move: () => import('./move-tool.js'),
+        split: () => import('./split-tool.js'),
     },
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         // Priority 4 mirrors the legacy WallSystem's useFrame priority.
         priority: 4,
     },
@@ -171,20 +200,20 @@ export const wallDefinition = {
     },
     floorplanMoveTarget: wallFloorplanMoveTarget,
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
+    // The gesture row follows the Rooms variant picked in the Build panel (the
+    // HUD header names it); the variant itself is never cycled from here.
     toolHints: [
-        { key: 'Left click', label: 'Set wall start / end' },
         {
-            key: 'R',
-            label: 'Shape',
-            chip: {
-                subscribe: (onChange) => useWallDrawingMode.subscribe(onChange),
-                value: () => useWallDrawingMode.getState().mode,
-                cycle: () => useWallDrawingMode.getState().toggle(),
-                labels: { line: 'Shape: Line', rectangle: 'Shape: Rectangle' },
-                icons: { line: 'lucide:minus', rectangle: 'lucide:square' },
-                tooltip: 'Wall shape — click or press R to toggle',
-            },
+            key: 'Left click',
+            label: 'Set one corner, then the opposite',
+            visible: whenWallVariant('rectangle'),
+        },
+        {
+            key: 'Left click',
+            label: 'Add a corner · click the first to close',
+            visible: whenWallVariant('polygon'),
         },
+        { key: 'Left click', label: 'Set wall start / end', visible: whenWallVariant('walls') },
         { key: 'Esc', label: 'Cancel' },
     ],
     // The split session (`split-session.ts`) is the wall's own reshape; the HUD

package/dist/wall/exterior.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode } from '@pascal-app/core';
+/** A wall with an outdoor face: the cutaway treats it as a wall seen from outside or inside. */
+export declare function wallSeenFromOutside(node: AnyNode): boolean;
+/** An opening in a roof segment, or in a wall with an outdoor face, is seen from outside. */
+export declare function openingSeenFromOutside(node: AnyNode, nodes: Readonly<Record<string, AnyNode>>): boolean;
+//# sourceMappingURL=exterior.d.ts.map

package/dist/wall/exterior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exterior.d.ts","sourceRoot":"","sources":["../../src/wall/exterior.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,gGAAgG;AAChG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAE1D;AAED,6FAA6F;AAC7F,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,CAKT"}

package/dist/wall/exterior.js

@@ -0,0 +1,13 @@
+/** A wall with an outdoor face: the cutaway treats it as a wall seen from outside or inside. */
+export function wallSeenFromOutside(node) {
+    return node.type === 'wall' && (node.frontSide === 'exterior' || node.backSide === 'exterior');
+}
+/** An opening in a roof segment, or in a wall with an outdoor face, is seen from outside. */
+export function openingSeenFromOutside(node, nodes) {
+    if (node.type !== 'door' && node.type !== 'window')
+        return false;
+    if (node.roofSegmentId)
+        return true;
+    const host = nodes[node.wallId ?? node.parentId ?? ''];
+    return host ? wallSeenFromOutside(host) : false;
+}

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

@@ -23,7 +23,7 @@ import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Existing automatic slabs and ceilings receive live polygon overrides during
+ * Existing slabs, ceilings and zones receive live polygon overrides during
  * the drag. New surfaces and removals stay deferred until commit because live
  * overrides cannot represent nodes that do not exist in the scene.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,mBAAmB,EAaxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAuYjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAgVjE,CAAA"}

package/dist/wall/floorplan-move.js

@@ -1,13 +1,7 @@
-import { detectSpacesForLevel, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
+import { createLevelStructurePreview, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallEndRejoins, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
-import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
-function getLevelSlabs(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
-}
-function getLevelCeilings(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
-}
+import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared.js';
 /**
  * 2D floor-plan move handler for wall.
  *
@@ -32,7 +26,7 @@ function getLevelCeilings(levelId, nodes) {
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Existing automatic slabs and ceilings receive live polygon overrides during
+ * Existing slabs, ceilings and zones receive live polygon overrides during
  * the drag. New surfaces and removals stay deferred until commit because live
  * overrides cannot represent nodes that do not exist in the scene.
  */
@@ -78,40 +72,22 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
     const levelId = node.parentId ?? null;
+    const previewStructure = levelId
+        ? createLevelStructurePreview(levelId, useScene.getState().nodes)
+        : null;
+    const dragNodes = Object.fromEntries(Object.values(useScene.getState().nodes)
+        .filter((node) => node.parentId === levelId)
+        .map((node) => [node.id, node]));
     const affectedIds = [wallId, ...linkedOriginals.map((wall) => wall.id)];
     const affectedIdSet = new Set(affectedIds);
     const touchedSurfaceIds = new Set();
-    let latestSurfacePlans = null;
-    const planSurfaces = (walls) => {
-        if (!levelId)
-            return null;
-        const sceneState = useScene.getState();
-        const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
-        const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
-        const slabs = planAutoSlabsForLevel(roomPolygons, getLevelSlabs(levelId, sceneState.nodes));
-        const levelNode = sceneState.nodes[levelId];
-        const ceilings = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
-            storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
-            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
-        });
-        return { slabs, ceilings };
-    };
     const publishSurfacePreviews = (walls) => {
-        const plans = planSurfaces(walls);
-        latestSurfacePlans = plans;
-        if (!plans)
+        if (!previewStructure)
             return;
-        const entries = [];
-        for (const update of plans.slabs.update) {
-            if (update.data.polygon !== undefined) {
-                entries.push([update.id, { polygon: update.data.polygon }]);
-            }
-        }
-        for (const update of plans.ceilings.update) {
-            if (update.data.polygon !== undefined || update.data.height !== undefined) {
-                entries.push([update.id, update.data]);
-            }
-        }
+        const updates = previewStructure(walls);
+        const entries = updates.flatMap((update) => 'polygon' in update.data || 'holes' in update.data
+            ? [[update.id, update.data]]
+            : []);
         const nextIds = new Set(entries.map(([id]) => id));
         const overrides = useLiveNodeOverrides.getState();
         const sceneState = useScene.getState();
@@ -142,7 +118,6 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             sceneState.markDirty(id);
         }
         touchedSurfaceIds.clear();
-        latestSurfacePlans = null;
     };
     const session = {
         affectedIds,
@@ -222,7 +197,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // `existingWalls` snapshot needs the post-drag layout so duplicate
             // detection works; we synthesise it from scene state + the
             // overrides we just published (zustand is still on baseline).
-            const previewSceneWalls = getWallsAfterUpdates(useScene.getState().nodes, [
+            const previewSceneWalls = getWallsAfterUpdates(dragNodes, [
                 { id: wallId, data: { start: nextStart, end: nextEnd } },
                 ...linkedUpdates.map((u) => ({ id: u.id, data: { start: u.start, end: u.end } })),
             ]).filter((wall) => !collapsedIds.has(wall.id));
@@ -306,49 +281,11 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
-            const finalWalls = [
-                ...existingWalls,
-                ...bridgeCreates.map((entry) => ({ ...entry.node, parentId: entry.parentId ?? null })),
-            ];
-            const surfacePlans = planSurfaces(finalWalls) ?? latestSurfacePlans;
-            const surfaceUpdates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                    ...surfacePlans.ceilings.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                ]
-                : [];
-            const surfaceCreates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.create.map((slab) => ({
-                        node: slab,
-                        parentId: levelId,
-                    })),
-                    ...surfacePlans.ceilings.create.map((ceiling) => ({
-                        node: ceiling,
-                        parentId: levelId,
-                    })),
-                ]
-                : [];
-            const surfaceDeletes = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.delete.map((id) => id),
-                    ...surfacePlans.ceilings.delete.map((id) => id),
-                ]
-                : [];
-            sceneState.applyNodeChanges({
-                update: [
-                    ...commitUpdates,
-                    ...surfaceUpdates,
-                ],
-                create: [...bridgeCreates, ...surfaceCreates],
-                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
-            });
+            sceneState.applyNodeChanges(planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: commitUpdates,
+                create: bridgeCreates,
+                delete: Array.from(collapsedLinkedWallIds),
+            }));
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
             // double-merging the same values and would shadow any genuine

package/dist/wall/floorplan-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-tool.tsx"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,oBAAoB,EAO1B,MAAM,oBAAoB,CAAA;AAK3B,oGAAoG;AACpG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,sCAIpE"}
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-tool.tsx"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,oBAAoB,EAQ1B,MAAM,oBAAoB,CAAA;AAI3B,oGAAoG;AACpG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,sCAEpE"}

package/dist/wall/floorplan-tool.js

@@ -1,15 +1,12 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, resolveTerrainWallConstructionOptions, useScene, } from '@pascal-app/core';
-import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, useWallDrawVariant, } from '@pascal-app/editor';
 import { useEffect, useRef, useState } from 'react';
-import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
-import { createWallRectangle } from './rectangle-command';
+import { createWallRectangle } from './rectangle-command.js';
 /** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
 export default function WallFloorplanTool(props) {
-    useWallDrawingModeKeys();
-    const mode = useWallDrawingMode((s) => s.mode);
-    return mode === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
+    return useWallDrawVariant() === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
 }
 /**
  * Rectangle mode in the floor plan. Pointer moves stay with the panel, so the
@@ -80,12 +77,14 @@ function RectangleFloorplanTool({ activeLevelId }) {
             if (e.button === 0)
                 claim(e);
         };
-        // The panel publishes the snapped cursor only when it moves to a new
-        // point, so each change while a corner is down is the line draft's tick.
-        const stopTick = useFloorplanDraftPreview.subscribe((state, previous) => {
+        // The panel moves the snapped cursor; the wall draft's tick as the dragged
+        // corner steps to a new spot.
+        const stopTicks = useFloorplanDraftPreview.subscribe((state, previous) => {
+            const [now, before] = [state.cursorPoint, previous.cursorPoint];
             if (state.wallRectangleDraftStart &&
-                state.cursorPoint &&
-                state.cursorPoint !== previous.cursorPoint)
+                now &&
+                before &&
+                (now[0] !== before[0] || now[1] !== before[1]))
                 triggerSFX('sfx:grid-snap');
         });
         svg.addEventListener('pointerdown', onDown, true);
@@ -93,7 +92,7 @@ function RectangleFloorplanTool({ activeLevelId }) {
         svg.addEventListener('dblclick', stopDouble, true);
         emitter.on('tool:cancel', cancel);
         return () => {
-            stopTick();
+            stopTicks();
             svg.removeEventListener('pointerdown', onDown, true);
             svg.removeEventListener('click', onClick, true);
             svg.removeEventListener('dblclick', stopDouble, true);

package/dist/wall/floorplan.d.ts

@@ -1,10 +1,12 @@
-import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallMiterData, type WallNode } from '@pascal-app/core';
-import { type WallConstructionDimensionPlan } from './construction-dimensions';
-declare const WALL_DIMENSION_REFERENCES: readonly ["finished-faces", "centerline", "stud-faces"];
+import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallLayerMiterData, type WallMiterData, type WallNode } from '@pascal-app/core';
+import { type WallConstructionDimensionPlan } from './construction-dimensions.js';
+declare const WALL_DIMENSION_REFERENCES: readonly ['finished-faces', 'centerline', 'stud-faces'];
 type WallDimensionReference = (typeof WALL_DIMENSION_REFERENCES)[number];
 export type WallFloorplanLevelData = {
     miters: WallMiterData;
     documentMiters: WallMiterData;
+    layerMiters: WallLayerMiterData;
+    documentLayerMiters: WallLayerMiterData;
     constructionDimensionsByReference: Record<WallDimensionReference, WallConstructionDimensionPlan>;
 };
 export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAQpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAalC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA8NjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAYpB,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAalC,QAAA,MAAM,yBAAyB,YAAI,gBAAgB,EAAE,YAAY,EAAE,YAAY,CAAU,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAsBxE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,WAAW,EAAE,kBAAkB,CAAA;IAC/B,mBAAmB,EAAE,kBAAkB,CAAA;IACvC,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAqJD,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CA0CzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAgPjG"}