@pascal-app/nodes 0.1.1 → 1.0.0-beta.1

package/dist/construction-dimension/panel.js

@@ -0,0 +1,128 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { resolveConstructionDimensionDrawingOverride, resolveConstructionDimensionDrawingPresentation, setConstructionDimensionDrawingPresentation, setConstructionDimensionDrawingSuppressedSegments, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, DRAWING_TYPE_OPTIONS, PanelSection, PanelWrapper, SliderControl, triggerSFX, useDrawingView, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Trash2 } from 'lucide-react';
+import { useShallow } from 'zustand/react/shallow';
+const MODE_LABELS = {
+    linear: 'Linear',
+    radius: 'Radius',
+    diameter: 'Diameter',
+    'center-mark': 'Center mark',
+    chord: 'Chord',
+    'arc-length': 'Arc length',
+    angular: 'Angular',
+    coordinate: 'Coordinate',
+};
+const DATUM_POLICY_OPTIONS = [
+    { label: 'Centerline', value: 'centerline' },
+    { label: 'Wall face', value: 'wall-face' },
+    { label: 'Structural face', value: 'structural-face' },
+    { label: 'Finish face', value: 'finish-face' },
+];
+const TERMINATOR_OPTIONS = [
+    { label: 'Architectural tick', value: 'architectural-tick' },
+    { label: 'Filled arrow', value: 'filled-arrow' },
+    { label: 'Open arrow', value: 'open-arrow' },
+    { label: 'Dot', value: 'dot' },
+];
+const TEXT_POSITION_OPTIONS = [
+    { label: 'Above line', value: 'above' },
+    { label: 'Centered on line', value: 'centered' },
+];
+const IMPERIAL_PRECISION_OPTIONS = [
+    { label: 'Nearest inch', value: '1' },
+    { label: 'Nearest 1/2 inch', value: '1/2' },
+    { label: 'Nearest 1/4 inch', value: '1/4' },
+    { label: 'Nearest 1/8 inch', value: '1/8' },
+    { label: 'Nearest 1/16 inch', value: '1/16' },
+];
+const METRIC_NOTATION_OPTIONS = [
+    { label: 'Meters', value: 'meters' },
+    { label: 'Millimeters', value: 'millimeters' },
+];
+export default function ConstructionDimensionPanel() {
+    const selectedId = useViewer((state) => state.selection.selectedIds[0]);
+    const setSelection = useViewer((state) => state.setSelection);
+    const dimension = useScene((state) => {
+        const node = selectedId ? state.nodes[selectedId] : undefined;
+        return node?.type === 'construction-dimension' ? node : null;
+    });
+    const updateNode = useScene((state) => state.updateNode);
+    const deleteNode = useScene((state) => state.deleteNode);
+    const activeDrawingType = useDrawingView((state) => state.drawingType);
+    if (!(dimension && selectedId))
+        return null;
+    const update = (patch) => updateNode(dimension.id, patch);
+    const supportsCenterMark = ['radius', 'diameter', 'arc-length', 'angular'].includes(dimension.mode);
+    const activeDrawingLabel = DRAWING_TYPE_OPTIONS.find((option) => option.id === activeDrawingType)?.label ?? 'Floor plan';
+    const activePresentation = resolveConstructionDimensionDrawingPresentation(dimension, activeDrawingType);
+    const activeDrawingOverride = resolveConstructionDimensionDrawingOverride(dimension, activeDrawingType);
+    const suppressedSegmentsText = formatSuppressedSegments(activeDrawingOverride?.suppressedSegmentIndexes ?? []);
+    const updateDrawingPresentation = (drawingType, presentation) => {
+        const drawingOverrides = setConstructionDimensionDrawingPresentation(dimension, drawingType, presentation);
+        const firstFoundationController = presentation === 'controlled' && !dimension.controllingDimensionId
+            ? selectFoundationControllers(useScene.getState().nodes, dimension.id)[0]
+            : undefined;
+        update({
+            drawingOverrides,
+            ...(presentation === 'controlled' && !dimension.controllingDimensionId
+                ? { controllingDimensionId: firstFoundationController?.id ?? null }
+                : {}),
+        });
+    };
+    const updateSuppressedSegments = (value) => {
+        update({
+            drawingOverrides: setConstructionDimensionDrawingSuppressedSegments(dimension, activeDrawingType, parseSuppressedSegments(value)),
+        });
+    };
+    return (_jsxs(PanelWrapper, { icon: "/icons/blueprint.webp", onClose: () => setSelection({ selectedIds: [] }), title: "Construction Dimension", width: 320, children: [_jsxs(PanelSection, { title: "Dimension", children: [_jsxs("div", { className: "flex items-center justify-between gap-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Mode" }), _jsx("span", { className: "font-medium text-foreground", children: MODE_LABELS[dimension.mode] })] }), _jsx(SliderControl, { label: "Feature count", max: 999, min: 1, onChange: (featureCount) => update({ featureCount }), precision: 0, step: 1, value: dimension.featureCount }), supportsCenterMark ? (_jsxs("label", { className: "flex items-center justify-between gap-3 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: "Center mark" }), _jsx("input", { checked: dimension.showCenterMark, onChange: (event) => update({ showCenterMark: event.target.checked }), type: "checkbox" })] })) : null] }), _jsxs(PanelSection, { title: "Drawing coordination", children: [_jsx(SelectField, { label: "Primary drawing", onChange: (drawingType) => update({ drawingType: drawingType }), options: DRAWING_TYPE_OPTIONS.map((option) => ({
+                            label: option.label,
+                            value: option.id,
+                        })), value: dimension.drawingType }), _jsx(SelectField, { label: `${activeDrawingLabel} presentation`, onChange: (presentation) => updateDrawingPresentation(activeDrawingType, presentation), options: [
+                            { label: 'Shown', value: 'shown' },
+                            { label: 'Omitted', value: 'omit' },
+                            ...(activeDrawingType === 'floor-plan'
+                                ? [{ label: 'Controlled by foundation', value: 'controlled' }]
+                                : []),
+                        ], value: activePresentation }), activeDrawingType === 'floor-plan' && activePresentation === 'controlled' ? (_jsx(FoundationControllerField, { dimensionId: dimension.id, onChange: (controllingDimensionId) => update({
+                            controllingDimensionId,
+                        }), value: dimension.controllingDimensionId ?? '' })) : null, _jsx("p", { className: "text-muted-foreground text-xs", children: "Linked dimensions reuse the controller's associative anchors and update with it." }), _jsx(TextField, { label: `${activeDrawingLabel} suppressed segments`, onCommit: updateSuppressedSegments, placeholder: "e.g. 2, 4", value: suppressedSegmentsText }), _jsx("p", { className: "text-muted-foreground text-xs", children: "Segment numbers are one-based and apply only in this drawing view." })] }), _jsxs(PanelSection, { title: "Notation", children: [_jsx(TextField, { label: "Prefix", onCommit: (prefix) => update({ prefix }), value: dimension.prefix }), _jsx(TextField, { label: "Suffix", onCommit: (suffix) => update({ suffix }), value: dimension.suffix }), _jsx(TextField, { label: "Text override", onCommit: (textOverride) => update({ textOverride: textOverride || null }), placeholder: "Use measured value", value: dimension.textOverride ?? '' })] }), _jsxs(PanelSection, { title: "Standards", children: [_jsx(SelectField, { label: "Datum policy", onChange: (datumPolicy) => update({ datumPolicy: datumPolicy }), options: DATUM_POLICY_OPTIONS, value: dimension.datumPolicy }), _jsx(SelectField, { label: "Terminator", onChange: (terminator) => update({ terminator: terminator }), options: TERMINATOR_OPTIONS, value: dimension.terminator }), _jsx(SelectField, { label: "Text position", onChange: (textPosition) => update({ textPosition: textPosition }), options: TEXT_POSITION_OPTIONS, value: dimension.textPosition }), _jsx(SelectField, { label: "Imperial precision", onChange: (imperialPrecision) => update({
+                            imperialPrecision: imperialPrecision,
+                        }), options: IMPERIAL_PRECISION_OPTIONS, value: dimension.imperialPrecision }), _jsx(SelectField, { label: "Metric notation", onChange: (metricNotation) => update({ metricNotation: metricNotation }), options: METRIC_NOTATION_OPTIONS, value: dimension.metricNotation }), _jsx(SliderControl, { label: "Extension gap", max: 0.5, min: 0, onChange: (extensionStartGap) => update({ extensionStartGap }), precision: 3, step: 0.005, value: dimension.extensionStartGap }), _jsx(SliderControl, { label: "Extension overshoot", max: 0.5, min: 0, onChange: (extensionOvershoot) => update({ extensionOvershoot }), precision: 3, step: 0.005, value: dimension.extensionOvershoot })] }), _jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { className: "border-red-500/40 text-red-200 hover:bg-red-500/15", icon: _jsx(Trash2, { className: "h-4 w-4" }), label: "Delete", onClick: () => {
+                            triggerSFX('sfx:structure-delete');
+                            deleteNode(dimension.id);
+                            setSelection({ selectedIds: [] });
+                        } }) }) })] }));
+}
+function selectFoundationControllers(nodes, excludedId) {
+    return Object.values(nodes).filter((candidate) => candidate.type === 'construction-dimension' &&
+        candidate.id !== excludedId &&
+        candidate.drawingType === 'foundation-plan');
+}
+function FoundationControllerField({ dimensionId, value, onChange, }) {
+    const foundationControllers = useScene(useShallow((state) => selectFoundationControllers(state.nodes, dimensionId)));
+    return (_jsx(SelectField, { disabled: foundationControllers.length === 0, label: "Foundation controller", onChange: (controllingDimensionId) => onChange(controllingDimensionId), options: foundationControllers.map((controller) => ({
+            label: controller.name || 'Foundation dimension',
+            value: controller.id,
+        })), placeholder: "No foundation dimensions", value: value }));
+}
+function parseSuppressedSegments(value) {
+    return [
+        ...new Set(value
+            .split(/[,\s]+/)
+            .map((part) => Number.parseInt(part, 10))
+            .filter((index) => Number.isInteger(index) && index > 0)
+            .map((index) => index - 1)),
+    ].sort((left, right) => left - right);
+}
+function formatSuppressedSegments(indexes) {
+    return indexes.map((index) => index + 1).join(', ');
+}
+function SelectField({ label, value, options, placeholder, disabled, onChange, }) {
+    return (_jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsxs("select", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground disabled:opacity-50", disabled: disabled, onChange: (event) => onChange(event.target.value), value: value, children: [placeholder && options.length === 0 ? _jsx("option", { value: "", children: placeholder }) : null, options.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value)))] })] }));
+}
+function TextField({ label, value, placeholder, onCommit, }) {
+    return (_jsxs("label", { className: "space-y-1 text-sm", children: [_jsx("span", { className: "text-muted-foreground", children: label }), _jsx("input", { className: "w-full rounded-md border border-border/70 bg-background px-2 py-1.5 text-foreground", defaultValue: value, onBlur: (event) => onCommit(event.target.value), placeholder: placeholder }, value)] }));
+}

package/dist/construction-dimension/parametrics.d.ts

@@ -0,0 +1,3 @@
+import type { ConstructionDimensionNode, ParametricDescriptor } from '@pascal-app/core';
+export declare const constructionDimensionParametrics: ParametricDescriptor<ConstructionDimensionNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/construction-dimension/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvF,eAAO,MAAM,gCAAgC,EAAE,oBAAoB,CAAC,yBAAyB,CAG5F,CAAA"}

package/dist/construction-dimension/parametrics.js

@@ -0,0 +1,4 @@
+export const constructionDimensionParametrics = {
+    groups: [],
+    customPanel: () => import('./panel'),
+};

package/dist/construction-dimension/schema.d.ts

@@ -0,0 +1,2 @@
+export { ConstructionDimensionBaseline, ConstructionDimensionChainMode, ConstructionDimensionMode, ConstructionDimensionNode, } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/construction-dimension/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAA"}

package/dist/construction-dimension/schema.js

@@ -0,0 +1 @@
+export { ConstructionDimensionBaseline, ConstructionDimensionChainMode, ConstructionDimensionMode, ConstructionDimensionNode, } from '@pascal-app/core';

package/dist/door/contextual-dimensions.d.ts

@@ -0,0 +1,3 @@
+import type { DoorNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+export declare function buildDoorContextualDimensions(node: DoorNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=contextual-dimensions.d.ts.map

package/dist/door/contextual-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/door/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGpF,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAK1B"}

package/dist/door/contextual-dimensions.js

@@ -0,0 +1,7 @@
+import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions';
+export function buildDoorContextualDimensions(node, ctx) {
+    return buildWallHostedOpeningContextualDimensions(node, ctx, {
+        showClearancesWhileMoving: false,
+        useExteriorNormal: false,
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AAWzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAkInC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA6G1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AAkBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA4HnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAqH1D,CAAA"}

package/dist/door/definition.js

@@ -1,7 +1,10 @@
+import { buildDoorFloorplanSchedule, computeDoorFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
 import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
+import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
 import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
+import { buildDoorContextualDimensions } from './contextual-dimensions';
 import { scaleHandleHeight } from './door-math';
 import { buildDoorFloorplan } from './floorplan';
 import { doorWidthAffordance } from './floorplan-affordances';
@@ -25,12 +28,6 @@ function readWallLength(door, scene) {
         return Number.POSITIVE_INFINITY;
     return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 }
-function readWallHeight(door, scene) {
-    if (!door.wallId)
-        return Number.POSITIVE_INFINITY;
-    const wall = scene.get(door.wallId);
-    return wall?.height ?? Number.POSITIVE_INFINITY;
-}
 // Width arrow on the door-local +X (right) or -X (left) side. Drag grows
 // the door from the anchored OPPOSITE edge; the door's wall-local center
 // re-centers so the anchored edge stays put.
@@ -92,7 +89,7 @@ function doorHeightHandle() {
             if (roofMax !== null)
                 return Math.max(MIN_DOOR_HEIGHT, roofMax);
             const bottom = n.position[1] - n.height / 2;
-            return Math.max(MIN_DOOR_HEIGHT, readWallHeight(n, scene) - bottom);
+            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene) - bottom);
         },
         currentValue: (n) => n.height,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -158,9 +155,15 @@ export const doorDefinition = {
     kind: 'door',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: DoorNode,
     category: 'structure',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildDoorContextualDimensions,
+            schedule: buildDoorFloorplanSchedule,
+        },
+    },
     surfaceRole: 'joinery',
     // Leverage the schema's zod `.default()` annotations to compute the
     // full default shape — door has 40+ fields, listing them inline would
@@ -201,6 +204,7 @@ export const doorDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     system: {
         module: () => import('./system'),
         // Priority 3 mirrors the legacy DoorSystem (after animation at 2,
@@ -210,6 +214,7 @@ export const doorDefinition = {
     // Stage C: floor-plan polygon. Needs ctx.parent (the wall) to compute
     // direction + perpendicular for the cutout footprint.
     floorplan: buildDoorFloorplan,
+    computeFloorplanLevelData: computeDoorFloorplanLevelData,
     floorplanDependsOnSiblings: true,
     // Opening symbols position from `ctx.parent` (the host wall); merge the
     // walls' live drag overrides so the symbol tracks a wall / group drag in

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

@@ -11,11 +11,8 @@ import { type DoorNode, type FloorplanAffordance } from '@pascal-app/core';
  *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
  *     edge stays fixed.
  *
- * Uses the scene-write preview pattern (writes directly to `useScene`
- * each tick): the registry layer's `effectiveNode` only merges live
- * overrides for walls, so an override-based preview wouldn't show on
- * doors. The dispatcher snapshots / pauses history at start, so per-tick
- * scene writes still collapse to one undoable entry on commit.
+ * Preview state stays in the live override store so the scene graph is
+ * written only once, when the drag commits.
  */
 export declare const doorWidthAffordance: FloorplanAffordance<DoorNode>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/door/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CA6F7D,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuF7D,CAAA"}

package/dist/door/floorplan-affordances.js

@@ -1,4 +1,4 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 const MIN_DOOR_WIDTH = 0.3;
 /**
  * 2D drag affordance for the door's width side-arrows. Sister to the 3D
@@ -12,11 +12,8 @@ const MIN_DOOR_WIDTH = 0.3;
  *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
  *     edge stays fixed.
  *
- * Uses the scene-write preview pattern (writes directly to `useScene`
- * each tick): the registry layer's `effectiveNode` only merges live
- * overrides for walls, so an override-based preview wouldn't show on
- * doors. The dispatcher snapshots / pauses history at start, so per-tick
- * scene writes still collapse to one undoable entry on commit.
+ * Preview state stays in the live override store so the scene graph is
+ * written only once, when the drag commits.
  */
 export const doorWidthAffordance = {
     start({ node, payload, nodes, initialPlanPoint }) {
@@ -63,18 +60,11 @@ export const doorWidthAffordance = {
                 const newDoorX = anchorX + growDir * (newWidth / 2);
                 lastWidth = newWidth;
                 lastDoorX = newDoorX;
-                // Scene-write preview so the 2D plan + 3D viewer both pick up
-                // the change immediately. The dispatcher paused history at
-                // session start, so per-tick writes don't pollute undo.
-                useScene.getState().updateNodes([
-                    {
-                        id: doorId,
-                        data: {
-                            width: newWidth,
-                            position: [newDoorX, initialDoorY, initialDoorZ],
-                        },
-                    },
-                ]);
+                useLiveNodeOverrides.getState().set(doorId, {
+                    width: newWidth,
+                    position: [newDoorX, initialDoorY, initialDoorZ],
+                });
+                useScene.getState().markDirty(doorId);
             },
             canCommit() {
                 // Width is always clamped to >= MIN_DOOR_WIDTH inside apply, so
@@ -87,6 +77,7 @@ export const doorWidthAffordance = {
                 // fields that differ from the pre-drag snapshot — if the user
                 // drags back to the original size by accident, the diff is empty
                 // and the door would otherwise revert to its starting state).
+                useLiveNodeOverrides.getState().clear(doorId);
                 useScene.getState().updateNodes([
                     {
                         id: doorId,

package/dist/door/floorplan.d.ts

@@ -28,10 +28,9 @@ import type { DoorNode, FloorplanGeometry, GeometryContext } from '@pascal-app/c
  * mounted on). Returns null when the parent isn't a wall (orphaned
  * doors during placement etc.).
  *
- * Skipped vs the full legacy for now: hinge / strike cubes (small
- * indicator squares at the rotation pivots), rounded-opening shape
- * variants, panic bar markers. Those are rare visual variations the
- * follow-up port can revisit.
+ * Swing leaves include hinge / strike indicators and panic hardware
+ * when present. Rounded and arched heads are shown as dashed overhead
+ * lines because their geometry sits above the horizontal plan cut.
  */
 export declare function buildDoorFloorplan(node: DoorNode, ctx: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA0qBjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmvBjG"}

package/dist/door/floorplan.js

@@ -1,3 +1,5 @@
+import { readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
 /**
  * Stage C floor-plan builder for door. 1:1 visual port of the legacy
@@ -28,10 +30,9 @@ import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dim
  * mounted on). Returns null when the parent isn't a wall (orphaned
  * doors during placement etc.).
  *
- * Skipped vs the full legacy for now: hinge / strike cubes (small
- * indicator squares at the rotation pivots), rounded-opening shape
- * variants, panic bar markers. Those are rare visual variations the
- * follow-up port can revisit.
+ * Swing leaves include hinge / strike indicators and panic hardware
+ * when present. Rounded and arched heads are shown as dashed overhead
+ * lines because their geometry sits above the horizontal plan cut.
  */
 export function buildDoorFloorplan(node, ctx) {
     const wall = ctx.parent;
@@ -103,6 +104,25 @@ export function buildDoorFloorplan(node, ctx) {
             strokeLinejoin: 'round',
         },
     ];
+    if (node.openingShape !== 'rectangle') {
+        const overheadRise = Math.min(width, node.openingShape === 'arch' ? node.archHeight : node.cornerRadius) * 0.2;
+        const overheadSide = swingDirection === 'inward' ? 1 : -1;
+        const startX = cx - dirX * halfWidth;
+        const startZ = cz - dirZ * halfWidth;
+        const endX = cx + dirX * halfWidth;
+        const endZ = cz + dirZ * halfWidth;
+        children.push({
+            kind: 'path',
+            d: `M ${startX} ${startZ} Q ${cx + perpX * overheadRise * overheadSide} ${cz + perpZ * overheadRise * overheadSide} ${endX} ${endZ}`,
+            fill: 'none',
+            stroke: accentColor,
+            strokeWidth: showSelectedChrome ? 1.4 : 1,
+            strokeOpacity: 0.8,
+            strokeDasharray: '4 3',
+            strokeLinecap: 'round',
+            vectorEffect: 'non-scaling-stroke',
+        });
+    }
     // Swing geometry. A leaf is drawn as a wedge fill + dashed swing arc +
     // solid leaf line. `drawSwingLeaf` emits one leaf given its hinge, the
     // closed-leaf vector (hinge → strike, whose length is the swing
@@ -161,6 +181,45 @@ export function buildDoorFloorplan(node, ctx) {
             strokeLinecap: 'round',
             vectorEffect: 'non-scaling-stroke',
         });
+        const markerSize = Math.min(0.05, Math.max(0.025, radius * 0.05));
+        const markerHalf = markerSize / 2;
+        const hardwareMarkers = [
+            [hX, hZ],
+            [closedTipX, closedTipZ],
+        ];
+        for (const [markerX, markerZ] of hardwareMarkers) {
+            children.push({
+                kind: 'rect',
+                x: markerX - markerHalf,
+                y: markerZ - markerHalf,
+                width: markerSize,
+                height: markerSize,
+                fill: fillColor,
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome ? 1.4 : 1,
+                vectorEffect: 'non-scaling-stroke',
+            });
+        }
+        if (node.panicBar) {
+            const leafX = (tipX - hX) / radius;
+            const leafZ = (tipZ - hZ) / radius;
+            const barCenterX = hX + leafX * radius * 0.7;
+            const barCenterZ = hZ + leafZ * radius * 0.7;
+            const barHalfLength = Math.min(0.12, Math.max(0.06, depth * 0.75));
+            const barX = -leafZ * barHalfLength;
+            const barZ = leafX * barHalfLength;
+            children.push({
+                kind: 'line',
+                x1: barCenterX - barX,
+                y1: barCenterZ - barZ,
+                x2: barCenterX + barX,
+                y2: barCenterZ + barZ,
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome ? 2.6 : 2.2,
+                strokeLinecap: 'square',
+                vectorEffect: 'non-scaling-stroke',
+            });
+        }
     };
     const isDoubleLeaf = node.doorType === 'double' || node.doorType === 'french';
     const isFolding = node.doorType === 'folding';
@@ -681,12 +740,35 @@ export function buildDoorFloorplan(node, ctx) {
     // Placement-measurement dimensions — distances to adjacent openings
     // (or wall ends) on each side. Only visible while actively moving
     // (the user clicked Move or grabbed the orange dot).
-    if (view?.moving) {
+    if (view?.moving && readFloorplanContext(ctx).automaticDimensions) {
         for (const dim of buildOpeningPlacementDimensions(node, ctx)) {
             children.push(dim);
         }
     }
-    return { kind: 'group', children };
+    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, {
+        preferredSide: swingSign === 1 ? -1 : 1,
+        stroke: showSelectedChrome ? '#f97316' : '#334155',
+    });
+    if (markAnnotation)
+        children.push(markAnnotation);
+    return { kind: 'group', children: children.map(markDoorPlanObstacle) };
+}
+function markDoorPlanObstacle(geometry) {
+    if (geometry.kind === 'group') {
+        const isOpeningMark = readFloorplanGeometryMetadata(geometry).annotationRole === 'opening-mark';
+        return isOpeningMark
+            ? geometry
+            : { ...geometry, children: geometry.children.map(markDoorPlanObstacle) };
+    }
+    if (geometry.kind === 'path' ||
+        geometry.kind === 'polygon' ||
+        geometry.kind === 'polyline' ||
+        geometry.kind === 'rect' ||
+        geometry.kind === 'circle' ||
+        geometry.kind === 'line') {
+        return withFloorplanGeometryMetadata(geometry, { annotationObstacle: 'bounds' });
+    }
+    return geometry;
 }
 /**
  * The opening's wall-normal orientation is encoded in the door's Y

package/dist/door/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,kBAAkB,CAAA;AA6CzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAg+B9C,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,kBAAkB,CAAA;AA6CzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAs+B9C,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/door/move-tool.js

@@ -155,7 +155,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end);
+        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId);
         const hideCursor = () => {
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
@@ -821,7 +821,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             if (hostWall?.type === 'wall') {
                 const wallAngle = Math.atan2(hostWall.end[1] - hostWall.start[1], hostWall.end[0] - hostWall.start[0]);
                 const ghostYaw = movingDoorNode.rotation[1] - wallAngle;
-                const seedPos = wallLocalToWorld(hostWall, movingDoorNode.position[0], movingDoorNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end));
+                const seedPos = wallLocalToWorld(hostWall, movingDoorNode.position[0], movingDoorNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId));
                 publishPlacementSurface(new Vector3(...seedPos), new Vector3(Math.sin(ghostYaw), 0, Math.cos(ghostYaw)));
                 // Claim the pointer for the wall so the floor free-follow stands down for
                 // the first frames after grab. Otherwise the first `grid:move` (the door

package/dist/door/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/door/panel.tsx"],"names":[],"mappings":"AAsIA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAmoChC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/door/panel.tsx"],"names":[],"mappings":"AAuIA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAmpChC"}

package/dist/door/panel.js

@@ -5,6 +5,7 @@ import { ActionButton, ActionGroup, cn, PanelSection, PanelWrapper, SegmentedCon
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, DoorOpen, FlipHorizontal2, Move, Trash2 } from 'lucide-react';
 import { useCallback, useRef } from 'react';
+import { OpeningDocumentationFields } from '../shared/opening-documentation-fields';
 import { scaleHandleHeight } from './door-math';
 const doorTypeOptions = [
     { label: 'Hinged', value: 'hinged', available: true },
@@ -201,6 +202,7 @@ export default function DoorPanel() {
         useScene.temporal.getState().pause();
         const cloned = structuredClone(node);
         delete cloned.id;
+        delete cloned.mark;
         cloned.metadata = { ...cloned.metadata, isNew: true };
         const duplicate = DoorNode.parse(cloned);
         useScene.getState().createNode(duplicate, node.parentId);
@@ -476,7 +478,7 @@ export default function DoorPanel() {
                                     ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
                                     : 'border-border/50 bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground', !option.available &&
                                     'cursor-not-allowed opacity-45 hover:bg-[#2C2C2E] hover:text-muted-foreground'), disabled: !option.available, onClick: () => handleUpdate(getDoorTypeUpdates(option.value)), type: "button", children: [_jsx(DoorOpen, { className: "h-4 w-4 shrink-0" }), _jsx("span", { className: "truncate font-medium", children: option.label })] }, option.value));
-                        }) }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "wall" })] }), max: 10, min: -10, onChange: (v) => handleUpdate({ position: [v, node.position[1], node.position[2]] }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), showFlipSide && (_jsx("div", { className: "px-1 pt-2 pb-1", children: _jsx(ActionButton, { className: "w-full", icon: _jsx(FlipHorizontal2, { className: "h-4 w-4" }), label: "Flip Side", onClick: handleFlip }) }))] }), showFoldSection && (_jsxs(PanelSection, { title: "Fold", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Panels" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ leafCount: v === '2' ? 2 : 4 }), options: [
+                        }) }))] }), _jsx(PanelSection, { title: "Documentation", children: _jsx(OpeningDocumentationFields, { constructionType: node.constructionType, dimensionReference: node.dimensionReference, finishOpeningHeight: node.finishOpeningHeight, finishOpeningWidth: node.finishOpeningWidth, mark: node.mark, masonryOpeningHeight: node.masonryOpeningHeight, masonryOpeningWidth: node.masonryOpeningWidth, onChange: handleUpdate, roughOpeningHeight: node.roughOpeningHeight, roughOpeningWidth: node.roughOpeningWidth }) }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "wall" })] }), max: 10, min: -10, onChange: (v) => handleUpdate({ position: [v, node.position[1], node.position[2]] }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), showFlipSide && (_jsx("div", { className: "px-1 pt-2 pb-1", children: _jsx(ActionButton, { className: "w-full", icon: _jsx(FlipHorizontal2, { className: "h-4 w-4" }), label: "Flip Side", onClick: handleFlip }) }))] }), showFoldSection && (_jsxs(PanelSection, { title: "Fold", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Panels" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ leafCount: v === '2' ? 2 : 4 }), options: [
                                         { label: '2', value: '2' },
                                         { label: '4', value: '4' },
                                     ], value: node.leafCount === 2 ? '2' : '4' })] }) }), _jsx(SliderControl, { label: "Open", max: 100, min: 0, onChange: (v) => handleUpdate({ operationState: v / 100 }), precision: 0, restoreOnCommit: false, step: 5, unit: "%", value: Math.round((node.operationState ?? 0) * 100) })] })), showSlideSection && (_jsxs(PanelSection, { title: "Slide", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: doorType === 'pocket' ? 'Pocket' : doorType === 'barn' ? 'Rail' : 'Panel' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ slideDirection: v }), options: [

package/dist/door/schema.d.ts

@@ -1,2 +1,2 @@
-export { DoorNode } from '@pascal-app/core';
+export { DoorNode, OpeningConstructionType, OpeningDimensionReference, } from '@pascal-app/core';
 //# sourceMappingURL=schema.d.ts.map

package/dist/door/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/door/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/door/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAA"}

package/dist/door/schema.js

@@ -1 +1 @@
-export { DoorNode } from '@pascal-app/core';
+export { DoorNode, OpeningConstructionType, OpeningDimensionReference, } from '@pascal-app/core';

package/dist/door/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/door/tool.tsx"],"names":[],"mappings":"AA8DA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAmnBrB,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/door/tool.tsx"],"names":[],"mappings":"AAiEA;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAkrBrB,CAAA;AAED,eAAe,QAAQ,CAAA"}