@pascal-app/nodes 1.0.7 → 1.1.0

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAqCzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA8BnC,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA8P1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

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

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

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

package/dist/wall/definition.edit.js

@@ -0,0 +1,184 @@
+import { DRAFTING_SURFACE_EXTENSION_KEY, getWallDrawVariant, PANEL_MODEL_EXTENSION, selectedWallDimensions, useEditor, } from '@pascal-app/editor';
+import { buildWallContextualDimensions } from './contextual-dimensions.js';
+import { hasWallCurveBlockingChildren } from './curve-eligibility.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 { wallPaint } from './paint.js';
+import { wallAssemblyMultiControls, wallReferenceModel, wallSettings, } from './panel-model.js';
+import { wallParametrics } from './parametrics.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.
+ *
+ * Stage A: registered (capabilities, relations, parametrics, presentation).
+ * Stage B: deferred — wall geometry depends on level-batch miter data that
+ *   doesn't fit the generic `(node, ctx) => Group` shape without `ctx.
+ *   levelData?.miters`. See plan's "GeometryContext" extension note.
+ *   `renderer` + `system` keep wrap-exporting legacy WallRenderer +
+ *   WallSystem + WallCutout.
+ * Stage C: `def.floorplan` builder produces the mitered plan footprint
+ *   polygon from shared floor-plan level data, with `ctx.siblings` as the
+ *   direct-caller fallback.
+ *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
+ *   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 wallEditContribution = {
+    snapProfile: 'structural',
+    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),
+                    },
+                    ...wallAssemblyMultiControls(selection),
+                ];
+            },
+        },
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'wall',
+            classifyFace: (node, localNormal) => {
+                if (node?.type !== 'wall')
+                    return null;
+                const dx = node.end[0] - node.start[0];
+                const dz = node.end[1] - node.start[1];
+                const length = Math.hypot(dx, dz);
+                if (length <= 1e-9)
+                    return { face: 'unknown' };
+                const sideDot = localNormal[0] * (-dz / length) + localNormal[2] * (dx / length);
+                if (Math.abs(localNormal[1]) > 0.7)
+                    return { face: 'top' };
+                if (Math.abs(localNormal[1]) < 0.25 && Math.abs(sideDot) > 0.7) {
+                    return { face: 'side', side: sideDot >= 0 ? 'front' : 'back' };
+                }
+                return { face: 'end' };
+            },
+        },
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool.js'),
+            reshapeLayers: { split: () => import('./split-floorplan-layer.js') },
+            contextualDimensions: buildWallContextualDimensions,
+            planHitSelectsNode: true,
+            selectionDimensions: ({ node, nodes, faces }) => selectedWallDimensions(nodes, node, faces),
+            actionMenu: {
+                actions: () => import('./actions.js'),
+                canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
+                    const child = nodes[childId];
+                    return child ? [child] : [];
+                })),
+            },
+        },
+    },
+    capabilities: {
+        // Paint dispatch for the interior / exterior side split. The
+        // editor's selection-manager routes paint hover / click /
+        // preview through this entry rather than carrying a kind-name
+        // arm.
+        paint: wallPaint,
+    },
+    parametrics: wallParametrics,
+    // Height arrow + side-move arrows + corner pickers all live in the legacy
+    // `wall-move-side-handles.tsx` component. The registry handle path didn't
+    // render correctly for walls specifically; revisit once that's diagnosed.
+    // Stage D — all four wall drag affordances live in this folder.
+    // curve / move-endpoint / move are 1:1 ports of the legacy tools
+    // (same snap pipelines, linked-wall corner cascade with
+    // `planWallMoveJunctions`, ALT-detach, bridge wall previews,
+    // auto-slab live preview, history dances). Placement is wired via
+    // `def.tool`.
+    tool: () => import('./tool.js'),
+    preview: () => import('./preview.js'),
+    affordanceTools: {
+        curve: () => import('./curve-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+        move: () => import('./move-tool.js'),
+        split: () => import('./split-tool.js'),
+    },
+    // Stage C: floor-plan rendering. Precomputes the level miter graph once
+    // per render pass, then the builder reads its own junctions by wall id.
+    computeFloorplanLevelData: computeWallFloorplanLevelData,
+    floorplan: buildWallFloorplan,
+    floorplanDependsOnSiblings: true,
+    // 2D drag affordances triggered by `endpoint-handle` primitives in
+    // `def.floorplan`'s output. Sister to `affordanceTools` (3D) — the
+    // same legacy `MoveWallEndpointTool` flow, reachable from both the
+    // R3F canvas and the floor-plan SVG.
+    floorplanAffordances: {
+        'move-endpoint': wallMoveEndpointAffordance,
+        curve: wallCurveAffordance,
+        thickness: wallThicknessAffordance,
+    },
+    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 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') },
+        // A started Polygon room holds square; Alt lets it go.
+        { key: 'Alt', label: 'Free angle', visible: whenWallVariant('polygon') },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    // The split session (`split-session.ts`) is the wall's own reshape; the HUD
+    // shows these while it runs. The snapping chip comes from the scope.
+    affordanceHints: {
+        split: [
+            { key: 'Left click', label: 'Split at the marks' },
+            {
+                key: 'Scroll',
+                label: 'Cuts',
+                chip: {
+                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
+                    value: () => String(useWallSplit.getState().draft?.cuts ?? 1),
+                    cycle: () => {
+                        const cuts = useWallSplit.getState().draft?.cuts ?? 1;
+                        setWallSplitCuts(cuts >= WALL_SPLIT_MAX_CUTS ? 1 : cuts + 1);
+                    },
+                    labels: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [
+                        count,
+                        count === '1' ? 'Cuts: 1' : `Cuts: ${count}, even`,
+                    ])),
+                    icons: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [count, 'lucide:scissors'])),
+                    tooltip: 'Number of cuts — scroll or click to change',
+                },
+            },
+            {
+                key: 'Alt',
+                label: 'Free placement',
+                // Several cuts are evenly spaced, so there is nothing to place freely.
+                visible: {
+                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
+                    value: () => (useWallSplit.getState().draft?.cuts ?? 1) === 1,
+                },
+            },
+            { key: 'Esc', label: 'Cancel' },
+        ],
+    },
+};

package/dist/wall/definition.js

@@ -1,279 +1,4 @@
-import { DEFAULT_WALL_THICKNESS, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, isRailingWall, wallSlots, } from '@pascal-app/core';
-import { DRAFTING_SURFACE_EXTENSION_KEY, getWallDrawVariant, PANEL_MODEL_EXTENSION, selectedWallDimensions, 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 { wallAssemblyMultiControls, 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.
- *
- * Stage A: registered (capabilities, relations, parametrics, presentation).
- * Stage B: deferred — wall geometry depends on level-batch miter data that
- *   doesn't fit the generic `(node, ctx) => Group` shape without `ctx.
- *   levelData?.miters`. See plan's "GeometryContext" extension note.
- *   `renderer` + `system` keep wrap-exporting legacy WallRenderer +
- *   WallSystem + WallCutout.
- * Stage C: `def.floorplan` builder produces the mitered plan footprint
- *   polygon from shared floor-plan level data, with `ctx.siblings` as the
- *   direct-caller fallback.
- *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
- *   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: 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),
-                    },
-                    ...wallAssemblyMultiControls(selection),
-                ];
-            },
-        },
-        [DRAFTING_SURFACE_EXTENSION_KEY]: {
-            kind: 'wall',
-            classifyFace: (node, localNormal) => {
-                if (node?.type !== 'wall')
-                    return null;
-                const dx = node.end[0] - node.start[0];
-                const dz = node.end[1] - node.start[1];
-                const length = Math.hypot(dx, dz);
-                if (length <= 1e-9)
-                    return { face: 'unknown' };
-                const sideDot = localNormal[0] * (-dz / length) + localNormal[2] * (dx / length);
-                if (Math.abs(localNormal[1]) > 0.7)
-                    return { face: 'top' };
-                if (Math.abs(localNormal[1]) < 0.25 && Math.abs(sideDot) > 0.7) {
-                    return { face: 'side', side: sideDot >= 0 ? 'front' : 'back' };
-                }
-                return { face: 'end' };
-            },
-        },
-        'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool.js'),
-            reshapeLayers: { split: () => import('./split-floorplan-layer.js') },
-            contextualDimensions: buildWallContextualDimensions,
-            planHitSelectsNode: true,
-            selectionDimensions: ({ node, nodes, faces }) => selectedWallDimensions(nodes, node, faces),
-            actionMenu: {
-                actions: () => import('./actions.js'),
-                canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
-                    const child = nodes[childId];
-                    return child ? [child] : [];
-                })),
-            },
-        },
-    },
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        start: [0, 0],
-        end: [3, 0],
-        frontSide: 'unknown',
-        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',
-            'railing',
-        ],
-        // Wall move is bespoke (endpoint drag, linked-wall corner cascade,
-        // ALT-detach). Omitting `movable` keeps the legacy MoveWallTool via
-        // capability-driven dispatch.
-        selectable: { hitVolume: 'bbox' },
-        // Front + back faces host items (paintings, shelves, switches).
-        surfaces: {
-            renderOpeningContent: (node) => !isRailingWall(node),
-            hosting: false,
-            top: {
-                height: (node, { nodes }) => {
-                    const wall = node;
-                    return (getWallBaseElevationForNodes(wall, nodes) + getWallEffectiveHeightForNodes(wall, nodes));
-                },
-            },
-            sides: { faces: 'all' },
-        },
-        duplicable: true,
-        deletable: true,
-        // Paint dispatch for the interior / exterior side split. The
-        // editor's selection-manager routes paint hover / click /
-        // preview through this entry rather than carrying a kind-name
-        // arm.
-        paint: wallPaint,
-        // Declared paintable slots with their default appearance — the same
-        // `{ slotId, label, default }` contract every other paintable kind exposes.
-        // 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'],
-        affectsSpatial: ['slab', 'ceiling', 'zone'],
-        linkedBy: 'endpoint-match',
-        cascadeDelete: 'descendants',
-    },
-    parametrics: wallParametrics,
-    // Height arrow + side-move arrows + corner pickers all live in the legacy
-    // `wall-move-side-handles.tsx` component. The registry handle path didn't
-    // render correctly for walls specifically; revisit once that's diagnosed.
-    // Stage D — all four wall drag affordances live in this folder.
-    // curve / move-endpoint / move are 1:1 ports of the legacy tools
-    // (same snap pipelines, linked-wall corner cascade with
-    // `planWallMoveJunctions`, ALT-detach, bridge wall previews,
-    // auto-slab live preview, history dances). Placement is wired via
-    // `def.tool`.
-    tool: () => import('./tool.js'),
-    preview: () => import('./preview.js'),
-    affordanceTools: {
-        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.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        // Priority 4 mirrors the legacy WallSystem's useFrame priority.
-        priority: 4,
-    },
-    // Stage C: floor-plan rendering. Precomputes the level miter graph once
-    // per render pass, then the builder reads its own junctions by wall id.
-    computeFloorplanLevelData: computeWallFloorplanLevelData,
-    floorplan: buildWallFloorplan,
-    measurement: {
-        features: (node) => wallMeasurementFeatures(node),
-        quickMeasure: (node) => wallQuickMeasurement(node),
-        match: (node, _ctx, point, maxDistance) => matchWallMeasurementFeature(node, point, maxDistance),
-        resolve: (node, _ctx, reference) => resolveWallMeasurementFeature(node, reference),
-    },
-    floorplanDependsOnSiblings: true,
-    // 2D drag affordances triggered by `endpoint-handle` primitives in
-    // `def.floorplan`'s output. Sister to `affordanceTools` (3D) — the
-    // same legacy `MoveWallEndpointTool` flow, reachable from both the
-    // R3F canvas and the floor-plan SVG.
-    floorplanAffordances: {
-        'move-endpoint': wallMoveEndpointAffordance,
-        curve: wallCurveAffordance,
-        thickness: wallThicknessAffordance,
-    },
-    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 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') },
-        // A started Polygon room holds square; Alt lets it go.
-        { key: 'Alt', label: 'Free angle', visible: whenWallVariant('polygon') },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    // The split session (`split-session.ts`) is the wall's own reshape; the HUD
-    // shows these while it runs. The snapping chip comes from the scope.
-    affordanceHints: {
-        split: [
-            { key: 'Left click', label: 'Split at the marks' },
-            {
-                key: 'Scroll',
-                label: 'Cuts',
-                chip: {
-                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
-                    value: () => String(useWallSplit.getState().draft?.cuts ?? 1),
-                    cycle: () => {
-                        const cuts = useWallSplit.getState().draft?.cuts ?? 1;
-                        setWallSplitCuts(cuts >= WALL_SPLIT_MAX_CUTS ? 1 : cuts + 1);
-                    },
-                    labels: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [
-                        count,
-                        count === '1' ? 'Cuts: 1' : `Cuts: ${count}, even`,
-                    ])),
-                    icons: Object.fromEntries(SPLIT_CUT_COUNTS.map((count) => [count, 'lucide:scissors'])),
-                    tooltip: 'Number of cuts — scroll or click to change',
-                },
-            },
-            {
-                key: 'Alt',
-                label: 'Free placement',
-                // Several cuts are evenly spaced, so there is nothing to place freely.
-                visible: {
-                    subscribe: (onChange) => useWallSplit.subscribe(onChange),
-                    value: () => (useWallSplit.getState().draft?.cuts ?? 1) === 1,
-                },
-            },
-            { key: 'Esc', label: 'Cancel' },
-        ],
-    },
-    presentation: {
-        label: 'Wall',
-        description: 'A straight or curved wall segment. Hosts doors, windows, lean-to extensions, and wall-mounted items.',
-        icon: { kind: 'url', src: '/icons/wall.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 10,
-    },
-    mcp: {
-        description: 'A wall defined by endpoints and optional curve sagitta. wallType selects standard, curtain or railing. curtainWall configures construction, framing, grids, glazing, spandrels, and zero-based panel overrides. Thickness is frame depth for curtain walls. A railing is an open guard (railing: style, postSpacing, postSize, infillSize, infillGap, bottomClearance, cap) that closes rooms like a wall; its height is its own (36 in by default), its thickness its posts, and a door on it is a gap in the guard.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { wallEditContribution } from './definition.edit.js';
+import { wallRenderDefinition } from './definition.render.js';
+export const wallDefinition = composeNodeDefinition(wallRenderDefinition, wallEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/wall/definition.render.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAQvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAsGxF,CAAA"}

package/dist/wall/definition.render.js

@@ -0,0 +1,100 @@
+import { DEFAULT_WALL_THICKNESS, getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, isRailingWall, wallSlots, } from '@pascal-app/core';
+import { wallSeenFromOutside } from './exterior.js';
+import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement.js';
+import { wallQuickMeasurement } from './quick-measurement.js';
+import { WallNode } from './schema.js';
+export const wallRenderDefinition = {
+    kind: 'wall',
+    schemaVersion: 10,
+    schema: WallNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        start: [0, 0],
+        end: [3, 0],
+        frontSide: 'unknown',
+        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',
+            'railing',
+        ],
+        // Wall move is bespoke (endpoint drag, linked-wall corner cascade,
+        // ALT-detach). Omitting `movable` keeps the legacy MoveWallTool via
+        // capability-driven dispatch.
+        selectable: { hitVolume: 'bbox' },
+        // Front + back faces host items (paintings, shelves, switches).
+        surfaces: {
+            renderOpeningContent: (node) => !isRailingWall(node),
+            hosting: false,
+            top: {
+                height: (node, { nodes }) => {
+                    const wall = node;
+                    return (getWallBaseElevationForNodes(wall, nodes) +
+                        Math.max(getWallEffectiveHeightForNodes(wall, nodes, 0), getWallEffectiveHeightForNodes(wall, nodes, 1)));
+                },
+            },
+            sides: { faces: 'all' },
+        },
+        duplicable: true,
+        deletable: true,
+        // Declared paintable slots with their default appearance — the same
+        // `{ slotId, label, default }` contract every other paintable kind exposes.
+        // 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'],
+        affectsSpatial: ['slab', 'ceiling', 'zone'],
+        linkedBy: 'endpoint-match',
+        cascadeDelete: 'descendants',
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        // Priority 4 mirrors the legacy WallSystem's useFrame priority.
+        priority: 4,
+    },
+    measurement: {
+        features: (node) => wallMeasurementFeatures(node),
+        quickMeasure: (node) => wallQuickMeasurement(node),
+        match: (node, _ctx, point, maxDistance) => matchWallMeasurementFeature(node, point, maxDistance),
+        resolve: (node, _ctx, reference) => resolveWallMeasurementFeature(node, reference),
+    },
+    presentation: {
+        label: 'Wall',
+        description: 'A straight or curved wall segment. Hosts doors, windows, lean-to extensions, and wall-mounted items.',
+        icon: { kind: 'url', src: '/icons/wall.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 10,
+    },
+    mcp: {
+        description: 'A wall defined by endpoints and optional curve sagitta. wallType selects standard, curtain or railing. curtainWall configures construction, framing, grids, glazing, spandrels, and zero-based panel overrides. Thickness is frame depth for curtain walls. A railing is an open guard (railing: style, postSpacing, postSize, infillSize, infillGap, bottomClearance, cap) that closes rooms like a wall; its height is its own (36 in by default), its thickness its posts, and a door on it is a gap in the guard.',
+    },
+};

package/dist/wall/floorplan.js

@@ -279,7 +279,7 @@ export function buildWallFloorplan(node, ctx) {
         },
     ];
     if (node.wallType === 'curtain') {
-        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
+        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}, 0), stroke, ctx.children));
     }
     else if (railing) {
         children.push(...buildRailingWallFloorplan(node, ctx.children, ctx.siblings.filter((sibling) => sibling.type === 'wall'), stroke));

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

@@ -1 +1 @@
-{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAGhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CA2F5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA8ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAgC3B"}
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAGhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAezB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAgG5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA+ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAiC3B"}