@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/column/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AA6nEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAgErE,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,UAAU,EAQhB,MAAM,kBAAkB,CAAA;AAunEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAmErE,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/column/renderer.js

@@ -1,11 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { collectDescendants, createSceneApi, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { COLUMN_BASE_DEFAULT, COLUMN_CAPITAL_DEFAULT, COLUMN_FRAME_DEFAULT, COLUMN_SHAFT_DEFAULT, collectDescendants, createSceneApi, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
 import { baseMaterial, createColumnBoxGeometry, createColumnCylinderGeometry, createColumnSphereGeometry, createColumnTorusGeometry, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, NodeRenderer, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { createContext, useContext, useEffect, useMemo, useRef } from 'react';
 import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { ScriptedOpeningModel } from '../shared/scripted-opening';
 import { columnCapitalBlocks, columnShaftLayout, getSegments, getShaftScaleAt, getShaftSegmentCount, getShaftTwistRadians, } from './shape';
-import { COLUMN_BASE_DEFAULT, COLUMN_CAPITAL_DEFAULT, COLUMN_FRAME_DEFAULT, COLUMN_SHAFT_DEFAULT, } from './slots';
 const DEFAULT_COLUMN_MATERIAL = baseMaterial();
 const DEFAULT_COLUMN_SLOT_MATERIALS = createSingleColumnMaterialMap(DEFAULT_COLUMN_MATERIAL);
 const ColumnMaterialContext = createContext(DEFAULT_COLUMN_SLOT_MATERIALS);
@@ -893,7 +893,7 @@ export const ColumnPreview = ({ node }) => {
             obj.raycast = () => { };
         });
     });
-    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsx("group", { ref: groupRef, children: _jsx(ColumnBody, { node: node }) }) }) }));
+    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsx("group", { ref: groupRef, children: node.source ? _jsx(ScriptedOpeningModel, { node: node }) : _jsx(ColumnBody, { node: node }) }) }) }));
 };
 export const ColumnRenderer = ({ node: rawNode }) => {
     const ref = useRef(null);
@@ -903,6 +903,8 @@ export const ColumnRenderer = ({ node: rawNode }) => {
     // override entry; unrelated writes don't re-render.
     const liveOverride = useLiveNodeOverrides((s) => s.overrides.get(rawNode.id));
     const node = useMemo(() => (liveOverride ? { ...rawNode, ...liveOverride } : rawNode), [rawNode, liveOverride]);
+    const scriptedColumn = Boolean(node.source);
+    const modelData = useMemo(() => ({ scriptedColumn }), [scriptedColumn]);
     const handlers = useNodeEvents(node, 'column');
     const liveTransform = useLiveTransforms((state) => state.get(node.id));
     const shading = useViewer((state) => state.shading);
@@ -933,6 +935,6 @@ export const ColumnRenderer = ({ node: rawNode }) => {
                 dirtySubtree();
         });
     }, [node]);
-    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsxs("group", { position: liveTransform?.position ?? node.position, ref: ref, rotation: [0, liveTransform?.rotation ?? node.rotation, 0], visible: node.visible, ...handlers, children: [_jsx(ColumnBody, { node: node }), node.children.map((id) => (_jsx(NodeRenderer, { nodeId: id }, id)))] }) }) }));
+    return (_jsx(ColumnMaterialContext.Provider, { value: materials, children: _jsx(ColumnEdgeSoftnessContext.Provider, { value: node.edgeSoftness ?? 0.025, children: _jsxs("group", { position: liveTransform?.position ?? node.position, ref: ref, rotation: [0, liveTransform?.rotation ?? node.rotation, 0], visible: node.visible, userData: modelData, ...handlers, children: [node.source ? _jsx(ScriptedOpeningModel, { node: node }) : _jsx(ColumnBody, { node: node }), node.children.map((id) => (_jsx(NodeRenderer, { nodeId: id }, id)))] }) }) }));
 };
 export default ColumnRenderer;

package/dist/column/surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../../src/column/surface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAExB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAoBzB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,EAAE,CAgDzE;AAED,eAAO,MAAM,qBAAqB,EAAE,eAUnC,CAAA"}
+{"version":3,"file":"surface.d.ts","sourceRoot":"","sources":["../../src/column/surface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAExB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAoBzB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,EAAE,CAuDzE;AAED,eAAO,MAAM,qBAAqB,EAAE,eAUnC,CAAA"}

package/dist/column/surface.js

@@ -10,6 +10,13 @@ function roundRegion(radius, segments, yaw = 0) {
     };
 }
 export function columnTopSurfaces(node) {
+    if (node.source)
+        return node.source.manifest.surfaces.map((surface, i) => ({
+            id: `top:${i}`,
+            position: [0, surface.y, 0],
+            normal: [0, 1, 0],
+            region: { kind: 'polygon', points: surface.polygon },
+        }));
     if (node.supportStyle !== 'vertical' || node.style === 'cluster')
         return [];
     const layout = columnShaftLayout(node);

package/dist/construction-dimension/floorplan.js

@@ -1,4 +1,4 @@
-import { constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, getWallThickness, } from '@pascal-app/core';
+import { constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, getWallLocalFaceZ, } from '@pascal-app/core';
 import { readFloorplanContext, readFloorplanMetricNotationOverride, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
 import { resolveMeasurementAnchor } from '../measurement/resolve';
 import { formatConstructionLength, } from '../shared/construction-length';
@@ -117,7 +117,7 @@ function wallDatumSide(node, featureId, resolved, frame) {
 function wallDatumOffset(wall, policy, side) {
     if (policy === 'centerline')
         return 0;
-    return (getWallThickness(wall) / 2) * side;
+    return getWallLocalFaceZ(wall, side > 0 ? 'a' : 'b');
 }
 function wallEndpointDatumExtension(wall, featureId, policy, ctx) {
     if (policy === 'centerline' || (featureId !== 'wall:start' && featureId !== 'wall:end')) {
@@ -135,7 +135,7 @@ function wallEndpointDatumExtension(wall, featureId, policy, ctx) {
         if (candidate?.type !== 'wall' ||
             candidate.id === wall.id ||
             getWallArcData(candidate) ||
-            (!pointsCoincide(endpoint, candidate.start) && !pointsCoincide(endpoint, candidate.end))) {
+            !(pointsCoincide(endpoint, candidate.start) || pointsCoincide(endpoint, candidate.end))) {
             continue;
         }
         const dx = candidate.end[0] - candidate.start[0];
@@ -339,6 +339,10 @@ function dimensionGeometry(node, start, end, dimensionStart, dimensionEnd, offse
         textPosition: node.textPosition,
         text,
         stroke,
+        // A typed value that could not drive geometry falls back to
+        // `textOverride`; the renderer badges it so the drawing never lies
+        // about being associative.
+        overridden: node.textOverride !== null,
     };
 }
 function arcGeometry(center, radius, startAngle, sweep, stroke) {

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA6FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAiE9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/cupola/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4FrC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA4D9D,CAAA"}

package/dist/cupola/definition.js

@@ -1,4 +1,4 @@
-import { CupolaNode as CupolaNodeSchema, } from '@pascal-app/core';
+import { CUPOLA_LOUVERS_DEFAULT, CupolaNode as CupolaNodeSchema, cupolaSlots, } from '@pascal-app/core';
 import { buildCupolaFloorplan } from './floorplan';
 import { cupolaPaint } from './paint';
 import { cupolaParametrics } from './parametrics';
@@ -9,7 +9,6 @@ const HEIGHT_HANDLE_OFFSET = 0.25;
 const ROTATE_CORNER_OFFSET = 0.12;
 const MIN_DIM = 0.3;
 const MIN_HEIGHT = 0.4;
-const CUPOLA_LOUVERS_DEFAULT = 'library:preset-metal';
 function getBodyMidY(n) {
     return Math.max(0.001, n.height) / 2;
 }
@@ -108,12 +107,7 @@ export const cupolaDefinition = {
         };
     },
     capabilities: {
-        slots: () => [
-            { slotId: 'base', label: 'Base', default: 'library:preset-softwhite' },
-            { slotId: 'body', label: 'Body', default: 'library:preset-softwhite' },
-            { slotId: 'roof', label: 'Roof', default: 'library:preset-softwhite' },
-            { slotId: 'louvers', label: 'Louvers', default: CUPOLA_LOUVERS_DEFAULT },
-        ],
+        slots: cupolaSlots,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAgQlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCA4OlC"}

package/dist/cupola/panel.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CupolaNode as CupolaSchema, getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
@@ -50,27 +50,9 @@ export default function CupolaPanel() {
         setSelection({ selectedIds: [] });
     }, [node, setMovingNode, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        const parentId = node.roofSegmentId;
-        if (!parentId)
-            return;
-        const state = useScene.getState();
-        const meta = typeof node.metadata === 'object' && node.metadata !== null
-            ? node.metadata
-            : {};
-        const cloneInput = {
-            ...node,
-            id: undefined,
-            metadata: { ...meta, isNew: true },
-        };
-        const cloned = CupolaSchema.parse(cloneInput);
-        state.createNode(cloned, parentId);
-        state.dirtyNodes.add(parentId);
-        setMovingNode(cloned);
-        setSelection({ selectedIds: [] });
-    }, [node, setMovingNode, setSelection]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleDelete = useCallback(() => {
         if (!(selectedId && node))
             return;

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;AAqBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAkKnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAsH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AA0BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAiKnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA4H1D,CAAA"}

package/dist/door/definition.js

@@ -1,10 +1,13 @@
+import { doorSlots } from '@pascal-app/core';
 import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
+import { doorBatchable } from '../shared/node-batch/batchable';
 import { buildDoorFloorplanSchedule, computeDoorFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { createOpeningPropertyPreview } from '../shared/opening-property-preview';
 import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
 import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
+import { scriptedOpeningHandles } from '../shared/scripted-opening-handles';
 import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
 import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
 import { buildDoorContextualDimensions } from './contextual-dimensions';
@@ -12,10 +15,11 @@ import { scaleHandleHeight } from './door-math';
 import { buildDoorFloorplan } from './floorplan';
 import { doorWidthAffordance } from './floorplan-affordances';
 import { doorFloorplanMoveTarget } from './floorplan-move';
+import { doorMechanism } from './mechanism';
 import { doorPaint } from './paint';
 import { doorParametrics } from './parametrics';
+import { DOOR_PLACEMENT_HINTS } from './placement';
 import { DoorNode } from './schema';
-import { doorSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_DOOR_HEIGHT = 0.5;
@@ -95,7 +99,7 @@ function doorHeightHandle() {
             if (curtainMax !== undefined)
                 return curtainMax;
             const bottom = n.position[1] - n.height / 2;
-            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene) - bottom);
+            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene, n) - bottom);
         },
         currentValue: (n) => n.height,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -212,6 +216,7 @@ export const doorDefinition = {
         return rest;
     },
     capabilities: {
+        batchable: doorBatchable,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -235,9 +240,12 @@ export const doorDefinition = {
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => doorSlots(),
         paint: doorPaint,
+        mechanism: doorMechanism,
     },
     parametrics: doorParametrics,
-    handles: doorHandles,
+    handles: (node) => node.source
+        ? [doorMoveHandle(), ...scriptedOpeningHandles(node, doorWidthHandle, doorHeightHandle)]
+        : doorHandles,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
@@ -284,6 +292,7 @@ export const doorDefinition = {
     },
     toolHints: [
         { key: 'Left click', label: 'Place door on wall' },
+        ...DOOR_PLACEMENT_HINTS,
         { key: 'R', label: 'Flip side' },
         { key: 'Alt', label: 'Force place' },
         { key: 'Esc', label: 'Cancel' },

package/dist/door/door-math.d.ts

@@ -8,16 +8,11 @@ import { type WallNode } from '@pascal-app/core';
  */
 export declare function scaleHandleHeight(handleHeight: number, oldHeight: number, newHeight: number): number;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  */
-export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
-/**
- * Clamps door center X so it stays fully within wall bounds.
- * Y is always height/2 — doors sit at floor level.
- */
-export declare function clampToWall(wallNode: WallNode, localX: number, width: number, height: number): {
-    clampedX: number;
-    clampedY: number;
-};
+export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number, localZ?: number): [number, number, number];
+/** Door centre on its wall: the shared rule in core (`clampDoorToWall`). */
+export { clampDoorToWall as clampToWall } from '@pascal-app/core/building';
 export { hasWallChildOverlap } from '../shared/wall-attach-target';
 //# sourceMappingURL=door-math.d.ts.map

package/dist/door/door-math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"door-math.d.ts","sourceRoot":"","sources":["../../src/door/door-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAOxC;AAKD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"door-math.d.ts","sourceRoot":"","sources":["../../src/door/door-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,EACjB,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAW1B;AAED,4EAA4E;AAC5E,OAAO,EAAE,eAAe,IAAI,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAK1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/door/door-math.js

@@ -1,4 +1,4 @@
-import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
+import { getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
 /**
  * Keep the door handle at the same relative height when the door is resized:
  * scale it by the height ratio, then clamp to the panel's slider bounds
@@ -11,24 +11,23 @@ export function scaleHandleHeight(handleHeight, oldHeight, newHeight) {
     return Math.min(Math.max(handleHeight * ratio, 0.5), Math.max(0.5, newHeight - 0.1));
 }
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  */
-export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0, localZ = 0) {
     const wallLength = getWallCurveLength(wallNode);
     const frame = getWallCurveFrameAt(wallNode, wallLength > 1e-6 ? localX / wallLength : 0);
-    return [frame.point.x, slabElevation + localY + levelYOffset, frame.point.y];
-}
-/**
- * Clamps door center X so it stays fully within wall bounds.
- * Y is always height/2 — doors sit at floor level.
- */
-export function clampToWall(wallNode, localX, width, height) {
-    const wallLength = getWallCurveLength(wallNode);
-    const margin = wallNode.wallType === 'curtain' ? getCurtainWallConfig(wallNode).perimeterWidth : 0;
-    const clampedX = Math.max(margin + width / 2, Math.min(wallLength - margin - width / 2, localX));
-    const clampedY = height / 2; // Doors always sit at floor level
-    return { clampedX, clampedY };
+    // `localZ` is measured from the body's centre plane, which a justified wall
+    // sets off its reference line.
+    const across = getWallBodyCenterOffset(wallNode) + localZ;
+    return [
+        frame.point.x + frame.normal.x * across,
+        slabElevation + localY + levelYOffset,
+        frame.point.y + frame.normal.y * across,
+    ];
 }
+/** Door centre on its wall: the shared rule in core (`clampDoorToWall`). */
+export { clampDoorToWall as clampToWall } from '@pascal-app/core/building';
 // Wall-child overlap is shared by door + window placement (one source of
 // truth in `shared/wall-attach-target.ts`). Re-exported here so existing
 // `./door-math` importers don't change.

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAqPjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAsPjE,CAAA"}

package/dist/door/floorplan-move.js

@@ -1,6 +1,7 @@
 import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
 import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset';
 import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
 import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
 import { clampToWall, hasWallChildOverlap } from './door-math';
@@ -175,7 +176,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             const side = flipped ? (hit.side === 'front' ? 'back' : 'front') : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
             lastValid = {
-                position: [clampedX, clampedY, 0],
+                // Same-wall moves keep the wall-local plane offset; another host resets it.
+                position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
                 rotation: [0, itemRotation, 0],
                 side,
                 parentId: hit.wall.id,

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;AAYzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmvBjG"}
+{"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;AAczB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAuxBjG"}

package/dist/door/floorplan.js

@@ -1,6 +1,8 @@
+import { getWallBodyCenterOffset } from '@pascal-app/core';
 import { readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
+import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset';
 /**
  * Stage C floor-plan builder for door. 1:1 visual port of the legacy
  * floorplan-panel door rendering:
@@ -52,9 +54,15 @@ export function buildDoorFloorplan(node, ctx) {
     const perpZ = dirX;
     const distance = node.position[0];
     const width = node.width;
-    const depth = wall.thickness ?? 0.1;
-    const cx = x1 + dirX * distance;
-    const cz = z1 + dirZ * distance;
+    const wallDepth = wall.thickness ?? 0.1;
+    const plane = resolveOpeningPlanPlane(node, wallDepth);
+    const depth = plane.depth;
+    // The plane offset is measured from the body centre, which a justified wall
+    // sets off its reference line.
+    const bodyOffset = getWallBodyCenterOffset(wall);
+    const across = bodyOffset + plane.offset;
+    const cx = x1 + dirX * distance + perpX * across;
+    const cz = z1 + dirZ * distance + perpZ * across;
     const halfWidth = width / 2;
     const halfDepth = depth / 2;
     const isPlanFlipped = isOpeningPlanFlipped(node.rotation);
@@ -79,6 +87,13 @@ export function buildDoorFloorplan(node, ctx) {
         [cx + dirX * halfWidth - perpX * halfDepth, cz + dirZ * halfWidth - perpZ * halfDepth],
         [cx - dirX * halfWidth - perpX * halfDepth, cz - dirZ * halfWidth - perpZ * halfDepth],
     ];
+    const halfWallDepth = wallDepth / 2;
+    const openingCutoutPoints = (ox, oz) => [
+        [ox - dirX * halfWidth + perpX * halfWallDepth, oz - dirZ * halfWidth + perpZ * halfWallDepth],
+        [ox + dirX * halfWidth + perpX * halfWallDepth, oz + dirZ * halfWidth + perpZ * halfWallDepth],
+        [ox + dirX * halfWidth - perpX * halfWallDepth, oz + dirZ * halfWidth - perpZ * halfWallDepth],
+        [ox - dirX * halfWidth - perpX * halfWallDepth, oz - dirZ * halfWidth - perpZ * halfWallDepth],
+    ];
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
@@ -92,6 +107,21 @@ export function buildDoorFloorplan(node, ctx) {
     const accentMuted = accentColor;
     const fillColor = showSelectedChrome ? '#fed7aa' : '#ffffff';
     const children = [
+        // An offset frame stands clear of the wall centre, but the wall is still
+        // cut through its whole thickness: draw that hole too.
+        ...(plane.offset === 0
+            ? []
+            : [
+                {
+                    kind: 'polygon',
+                    points: openingCutoutPoints(x1 + dirX * distance + perpX * bodyOffset, z1 + dirZ * distance + perpZ * bodyOffset),
+                    fill: fillColor,
+                    stroke: accentMuted,
+                    strokeWidth: showSelectedChrome ? 2 : 1.25,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinejoin: 'round',
+                },
+            ]),
         // Background — the cutout is filled white so the swing arc sits on
         // a clean canvas (the wall hatch shows through otherwise).
         {
@@ -718,24 +748,27 @@ export function buildDoorFloorplan(node, ctx) {
         // direction). Pointer-down on either routes through the door's
         // `resize-width` affordance — anchored at the opposite edge, clamped
         // to wall bounds. Mirrors the 3D `DoorSideArrow` width drag.
-        const startEdgeX = cx - dirX * halfWidth;
-        const startEdgeZ = cz - dirZ * halfWidth;
-        const endEdgeX = cx + dirX * halfWidth;
-        const endEdgeZ = cz + dirZ * halfWidth;
-        children.push({
-            kind: 'move-arrow',
-            point: [startEdgeX, startEdgeZ],
-            angle: Math.atan2(-dirZ, -dirX),
-            affordance: 'resize-width',
-            payload: { side: 'start' },
-        });
-        children.push({
-            kind: 'move-arrow',
-            point: [endEdgeX, endEdgeZ],
-            angle: Math.atan2(dirZ, dirX),
-            affordance: 'resize-width',
-            payload: { side: 'end' },
-        });
+        // A scripted opening's width is its script's: its size arrows live in 3D, on its params.
+        if (!node.source) {
+            const startEdgeX = cx - dirX * halfWidth;
+            const startEdgeZ = cz - dirZ * halfWidth;
+            const endEdgeX = cx + dirX * halfWidth;
+            const endEdgeZ = cz + dirZ * halfWidth;
+            children.push({
+                kind: 'move-arrow',
+                point: [startEdgeX, startEdgeZ],
+                angle: Math.atan2(-dirZ, -dirX),
+                affordance: 'resize-width',
+                payload: { side: 'start' },
+            });
+            children.push({
+                kind: 'move-arrow',
+                point: [endEdgeX, endEdgeZ],
+                angle: Math.atan2(dirZ, dirX),
+                affordance: 'resize-width',
+                payload: { side: 'end' },
+            });
+        }
     }
     // Placement-measurement dimensions — distances to adjacent openings
     // (or wall ends) on each side. Only visible while actively moving
@@ -748,6 +781,7 @@ export function buildDoorFloorplan(node, ctx) {
     const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, {
         preferredSide: swingSign === 1 ? -1 : 1,
         stroke: showSelectedChrome ? '#f97316' : '#334155',
+        drafting: readFloorplanContext(ctx).drafting,
     });
     if (markAnnotation)
         children.push(markAnnotation);

package/dist/door/mechanism.d.ts

@@ -0,0 +1,4 @@
+import { type MechanismCapability } from '@pascal-app/core';
+/** A door's leaf: Play opens it and Stop closes it, without touching the saved open state. */
+export declare const doorMechanism: MechanismCapability;
+//# sourceMappingURL=mechanism.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/door/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAIhF,8FAA8F;AAC9F,eAAO,MAAM,aAAa,EAAE,mBAiB3B,CAAA"}

package/dist/door/mechanism.js

@@ -0,0 +1,24 @@
+import { isOperationDoorType } from '@pascal-app/core';
+import { closeDoorOpenState, getDisplayedDoorValue, openDoorOpenState } from '@pascal-app/editor';
+import { scriptedOpening } from '../shared/scripted-opening';
+/** A door's leaf: Play opens it and Stop closes it, without touching the saved open state. */
+export const doorMechanism = {
+    verb: 'open',
+    icon: 'door',
+    has: (node) => node.type === 'door' &&
+        (node.source ? scriptedOpening.has(node) : node.openingKind !== 'opening'),
+    isOn: (node) => {
+        if (node.type !== 'door')
+            return false;
+        if (node.source)
+            return scriptedOpening.isOn(node);
+        return isOperationDoorType(node.doorType)
+            ? getDisplayedDoorValue(node.id, 'operationState', node.operationState) > 0
+            : getDisplayedDoorValue(node.id, 'swingAngle', node.swingAngle) > 0;
+    },
+    set: (node, on) => {
+        if (node.type === 'door' && node.source)
+            return scriptedOpening.set(node, on);
+        return (on ? openDoorOpenState : closeDoorOpenState)(node.id, { persist: false });
+    },
+};

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,EAYT,MAAM,kBAAkB,CAAA;AAmDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAwhC9C,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAcT,MAAM,kBAAkB,CAAA;AAoDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAyjC9C,CAAA;AAED,eAAe,YAAY,CAAA"}