@pascal-app/nodes 1.0.4 → 1.0.5

package/dist/stair/renderer.js

@@ -1,19 +1,20 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { computeSegmentTransforms, measureStairDetail, resolveArcStairConstruction, resolveStairArcLayout, resolveStairRailPaths, resolveStairWalkingPaths, rotateXZ, STAIR_RAILING_SLOT_DEFAULT, stairArcSliceCount, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
 import { getStairBodyMaterials, getStairRailingMaterial, NodeRenderer, OVERLAY_LAYER, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
-import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
-import { mergeGuardBoxes } from './baluster-geometry';
-import { balusterGuardRails, buildBalusterGuard } from './baluster-guard';
-import { boardsGuardRails, buildBoardsGuard } from './boards-guard';
-import { buildCableGuard, cableGuardRails } from './cable-guard';
-import { ContinuousStairRailings } from './continuous-railings';
-import { barBox, GUARD_PICKET_PITCH, GUARD_POST_SPACING, } from './guard-path';
-import { resolveStairBodySlotMaterials, resolveStairSegmentMaterials, resolveStairSlotMaterial, } from './materials';
-import { buildPostAndRailGuard, postAndRailGuardRails } from './post-and-rail-guard';
-import { useStairRenderData } from './use-stair-render-data';
+import { createPlaceholderGeometry } from '../shared/placeholder-geometry.js';
+import { mergeGuardBoxes } from './baluster-geometry.js';
+import { balusterGuardRails, buildBalusterGuard } from './baluster-guard.js';
+import { boardsGuardRails, buildBoardsGuard } from './boards-guard.js';
+import { buildCableGuard, cableGuardRails } from './cable-guard.js';
+import { ContinuousStairRailings } from './continuous-railings.js';
+import { barBox, GUARD_PICKET_PITCH, GUARD_POST_SPACING, } from './guard-path.js';
+import { resolveStairBodySlotMaterials, resolveStairSegmentMaterials, resolveStairSlotMaterial, } from './materials.js';
+import { buildPostAndRailGuard, postAndRailGuardRails } from './post-and-rail-guard.js';
+import { surfaceTransitionProfile } from './surface-transition.js';
+import { useStairRenderData } from './use-stair-render-data.js';
 export const StairRenderer = ({ node: rawNode }) => {
     const ref = useRef(null);
     // Merge any live drag override into the node so curved/spiral geometry
@@ -55,6 +56,7 @@ export const StairRenderer = ({ node: rawNode }) => {
     }), [segments]);
     const baseRailingMaterial = useMemo(() => getStairRailingMaterial(node, shading, textures, colorPreset), [node, shading, textures, colorPreset]);
     const railingMaterial = useMemo(() => resolveStairSlotMaterial(node, 'railing', STAIR_RAILING_SLOT_DEFAULT, baseRailingMaterial, sceneMaterials, shading, textures), [baseRailingMaterial, node, sceneMaterials, shading, textures]);
+    const onLevel = useScene((state) => node.parentId ? state.nodes[node.parentId]?.type === 'level' : true);
     // Each flight contributes tread and body material groups to the merged mesh.
     const straightPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(2), []);
     useEffect(() => {
@@ -62,11 +64,102 @@ export const StairRenderer = ({ node: rawNode }) => {
             straightPlaceholderGeometry.dispose();
         };
     }, [straightPlaceholderGeometry]);
-    return (_jsxs("group", { "position-x": node.position[0], "position-z": node.position[2], ref: ref, "rotation-y": node.rotation, visible: node.visible, userData: { pascalExportRefusal: detail.error }, ...handlers, children: [isSegmentBasedStair ? (_jsx("mesh", { castShadow: true, geometry: straightPlaceholderGeometry, material: mergedMaterials, name: "merged-stair", receiveShadow: true, userData: mergedSlotData })) : null, isSegmentBasedStair || detail.error ? null : (_jsx(CurvedStairBody, { bodyMaterials: bodyMaterials, stair: node, rise: totalRise })), detail.error ? null : segments.some((segment) => segment.winder) ||
+    return (_jsxs("group", { "position-x": node.position[0], ...(onLevel ? {} : { 'position-y': node.position[1] }), "position-z": node.position[2], ref: ref, "rotation-y": node.rotation, visible: node.visible, userData: { pascalExportRefusal: detail.error }, ...handlers, children: [isSegmentBasedStair ? (_jsx("mesh", { castShadow: true, geometry: straightPlaceholderGeometry, material: mergedMaterials, name: "merged-stair", receiveShadow: true, userData: mergedSlotData })) : null, isSegmentBasedStair || detail.error ? null : (_jsx(CurvedStairBody, { bodyMaterials: bodyMaterials, stair: node, rise: totalRise })), detail.error ? null : segments.some((segment) => segment.winder) ||
                 node.railingPath === 'continuous' ||
                 node.railingStyle === 'glass' ||
-                node.railingStyle === 'metal' ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData })) : (_jsxs(_Fragment, { children: [_jsx(StairRailings, { material: railingMaterial, stair: node, renderData: renderData }), node.handrail ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData, guard: false })) : null] })), _jsx(StairWalkingLine, { stair: node, segments: segments, totalRise: totalRise }), isSegmentBasedStair && !detail.error ? (_jsx("group", { name: "segments-wrapper", visible: false, children: (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) })) : null] }));
+                node.railingStyle === 'metal' ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData })) : (_jsxs(_Fragment, { children: [_jsx(StairRailings, { material: railingMaterial, stair: node, renderData: renderData }), node.handrail ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData, guard: false })) : null] })), isSegmentBasedStair && node.destinationSurfaceId && !detail.error ? (_jsx(StairSurfaceTransition, { stair: node, materials: bodyMaterials })) : null, _jsx(StairWalkingLine, { stair: node, segments: segments, totalRise: totalRise }), isSegmentBasedStair && !detail.error ? (_jsx("group", { name: "segments-wrapper", visible: false, children: (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) })) : null] }));
 };
+function StairSurfaceTransition({ stair, materials, }) {
+    const rawSurface = useScene((state) => state.nodes[stair.destinationSurfaceId]);
+    const surfaceOverride = useLiveNodeOverrides((state) => state.overrides.get(stair.destinationSurfaceId));
+    const surface = useMemo(() => (rawSurface && surfaceOverride ? { ...rawSurface, ...surfaceOverride } : rawSurface), [rawSurface, surfaceOverride]);
+    const flightId = stair.children[0];
+    const flight = useScene((state) => (flightId ? state.nodes[flightId] : undefined));
+    const flightOverride = useLiveNodeOverrides((state) => flightId ? state.overrides.get(flightId) : undefined);
+    const length = flightOverride?.length ??
+        flight?.length ??
+        0;
+    const segment = flight;
+    const fillToFloor = flightOverride?.fillToFloor ??
+        segment?.fillToFloor ??
+        stair.fillToFloor ??
+        true;
+    const thickness = flightOverride?.thickness ??
+        segment?.thickness ??
+        stair.thickness ??
+        0.25;
+    const segmentHeight = flightOverride?.height ?? segment?.height ?? 0;
+    const profile = useMemo(() => surface
+        ? surfaceTransitionProfile(stair, surface, length)
+        : null, [stair, surface, length]);
+    const geometry = useMemo(() => {
+        if (!profile)
+            return null;
+        const vertices = [];
+        const indices = [];
+        const top = stair.totalRise ?? 0;
+        const undersideOffset = segment?.segmentType === 'landing'
+            ? thickness
+            : thickness / Math.cos(Math.atan2(segmentHeight, length || 1));
+        const bottom = fillToFloor ? 0 : top - undersideOffset;
+        for (const [x, boundary] of profile.samples) {
+            vertices.push(x, top, length + profile.frontZ, x, top, length + boundary, x, bottom, length + profile.frontZ, x, bottom, length + boundary);
+        }
+        for (let i = 0; i < profile.samples.length - 1; i++) {
+            const a = i * 4, b = (i + 1) * 4;
+            indices.push(a, a + 1, b, b, a + 1, b + 1, a + 2, b + 2, a + 3, b + 2, b + 3, a + 3, a, b, a + 2, b, b + 2, a + 2, a + 1, a + 3, b + 1, b + 1, a + 3, b + 3);
+        }
+        const last = (profile.samples.length - 1) * 4;
+        indices.push(0, 2, 1, 1, 2, 3, last, last + 1, last + 2, last + 1, last + 3, last + 2);
+        const indexed = new THREE.BufferGeometry();
+        indexed.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        indexed.setIndex(indices);
+        const result = indexed.toNonIndexed();
+        indexed.dispose();
+        result.computeVertexNormals();
+        const position = result.getAttribute('position');
+        const normals = result.getAttribute('normal');
+        const uvs = [];
+        let currentMaterial = -1;
+        let groupStart = 0;
+        for (let i = 0; i < position.count; i += 3) {
+            const nx = Math.abs(normals.getX(i));
+            const ny = Math.abs(normals.getY(i));
+            const nz = Math.abs(normals.getZ(i));
+            const materialIndex = normals.getY(i) > 0.75 ? STAIR_TREAD_MATERIAL_INDEX : STAIR_SIDE_MATERIAL_INDEX;
+            if (materialIndex !== currentMaterial) {
+                if (i > groupStart)
+                    result.addGroup(groupStart, i - groupStart, currentMaterial);
+                groupStart = i;
+                currentMaterial = materialIndex;
+            }
+            for (let vertex = i; vertex < i + 3; vertex++) {
+                const x = position.getX(vertex), y = position.getY(vertex), z = position.getZ(vertex);
+                if (ny >= nx && ny >= nz)
+                    uvs.push(x, z);
+                else if (nx >= nz)
+                    uvs.push(z, y);
+                else
+                    uvs.push(x, y);
+            }
+        }
+        if (position.count > groupStart)
+            result.addGroup(groupStart, position.count - groupStart, currentMaterial);
+        result.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        result.setAttribute('uv2', new THREE.Float32BufferAttribute(uvs.slice(), 2));
+        return result;
+    }, [
+        profile,
+        length,
+        stair.totalRise,
+        fillToFloor,
+        thickness,
+        segmentHeight,
+        segment?.segmentType,
+    ]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    return geometry ? (_jsx("mesh", { castShadow: true, geometry: geometry, material: materials, name: "stair-surface-transition", receiveShadow: true, userData: STAIR_BODY_SLOT_USER_DATA })) : null;
+}
 function StairWalkingLine({ stair, segments, totalRise, }) {
     const selected = useViewer((state) => state.selection.selectedIds.includes(stair.id));
     const lines = useMemo(() => {
@@ -104,7 +197,7 @@ function StairRailings({ stair, material, renderData, }) {
     // guard — is a merged `GuardMesh` built on the shared path chassis, so each
     // reads as one coherent guard across straight, chained, winder, curved and
     // spiral layouts.
-    if ((stair.railingMode ?? 'none') === 'none') {
+    if (stair.destinationSurfaceId || (stair.railingMode ?? 'none') === 'none') {
         return null;
     }
     if (stair.stairType === 'curved' || stair.stairType === 'spiral') {
@@ -645,7 +738,7 @@ function buildSegmentRailPath(layouts, layoutIndex, side, landingInset) {
         points: [
             ...(previousLayout?.segment.segmentType === 'landing'
                 ? []
-                : [[flightStartX, stepHeight > 0 ? stepHeight : 0, flightSideOffset]]),
+                : [[flightStartX, Math.max(stepHeight, 0), flightSideOffset]]),
             ...Array.from({ length: steps }).map((_, index) => [
                 -segment.length / 2 + stepDepth * index + stepDepth / 2,
                 stepHeight * (index + 1),

package/dist/stair/stair-click-guard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Guards for the stair tool's commit triggers.
+ *
+ * One physical validation click can reach the stair tool's commit handler
+ * twice: node-surface clicks (`slab:click`, `wall:click`, …) are synthesized
+ * on *pointerup* by the viewer (`use-node-events`), while `grid:click` rides
+ * the browser's native *click* event from a canvas-level DOM listener
+ * (`use-grid-events`) that deliberately ignores R3F stopPropagation — and
+ * after a single-continuation commit the tool's emitter subscriptions survive
+ * until React unmounts it, which lands only after that native click. Without
+ * these guards a validation click over any node surface (a deck or floor
+ * slab, a wall, another stair) created TWO stairs from one click.
+ *
+ * Same hazard and same countermeasures as
+ * `packages/nodes/src/shared/floor-placement.ts` (`stopPlacementCommitPropagation`)
+ * and the `committed` flag in `move-registry-node-tool.tsx` — reimplemented
+ * here because `@pascal-app/editor` cannot depend on `@pascal-app/nodes`.
+ */
+export type StairCommitGate = {
+    /** True while the armed session may still commit. */
+    shouldCommit: () => boolean;
+    /**
+     * Mark the session exited (single continuation): every further click
+     * trigger reaching the still-subscribed handler — the native follow-up
+     * click, a stray second node click — is refused.
+     */
+    markExited: () => void;
+};
+export declare function createStairCommitGate(): StairCommitGate;
+type ClickSwallowTarget = {
+    addEventListener: (type: string, listener: (event: Event) => void, options?: AddEventListenerOptions) => void;
+    removeEventListener: (type: string, listener: (event: Event) => void, options?: EventListenerOptions) => void;
+};
+/**
+ * Eat the one native browser `click` that follows a pointerup-synthesized
+ * node click, before it reaches the canvas `grid:click` listener (capture
+ * phase on window runs first). Needed in repeat continuation too, where the
+ * tool stays armed and the gate above must keep allowing one commit per
+ * gesture. Self-disarms after the click or `timeoutMs`, whichever first.
+ */
+export declare function swallowFollowUpBrowserClick(target?: ClickSwallowTarget | undefined, timeoutMs?: number): void;
+export {};
+//# sourceMappingURL=stair-click-guard.d.ts.map

package/dist/stair/stair-click-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-click-guard.d.ts","sourceRoot":"","sources":["../../src/stair/stair-click-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,eAAe,GAAG;IAC5B,qDAAqD;IACrD,YAAY,EAAE,MAAM,OAAO,CAAA;IAC3B;;;;OAIG;IACH,UAAU,EAAE,MAAM,IAAI,CAAA;CACvB,CAAA;AAED,wBAAgB,qBAAqB,IAAI,eAAe,CAQvD;AAED,KAAK,kBAAkB,GAAG;IACxB,gBAAgB,EAAE,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,CAAC,EAAE,uBAAuB,KAC9B,IAAI,CAAA;IACT,mBAAmB,EAAE,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,CAAC,EAAE,oBAAoB,KAC3B,IAAI,CAAA;CACV,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,GAAE,kBAAkB,GAAG,SAA8D,EAC3F,SAAS,SAAM,GACd,IAAI,CAQN"}

package/dist/stair/stair-click-guard.js

@@ -0,0 +1,44 @@
+/**
+ * Guards for the stair tool's commit triggers.
+ *
+ * One physical validation click can reach the stair tool's commit handler
+ * twice: node-surface clicks (`slab:click`, `wall:click`, …) are synthesized
+ * on *pointerup* by the viewer (`use-node-events`), while `grid:click` rides
+ * the browser's native *click* event from a canvas-level DOM listener
+ * (`use-grid-events`) that deliberately ignores R3F stopPropagation — and
+ * after a single-continuation commit the tool's emitter subscriptions survive
+ * until React unmounts it, which lands only after that native click. Without
+ * these guards a validation click over any node surface (a deck or floor
+ * slab, a wall, another stair) created TWO stairs from one click.
+ *
+ * Same hazard and same countermeasures as
+ * `packages/nodes/src/shared/floor-placement.ts` (`stopPlacementCommitPropagation`)
+ * and the `committed` flag in `move-registry-node-tool.tsx` — reimplemented
+ * here because `@pascal-app/editor` cannot depend on `@pascal-app/nodes`.
+ */
+export function createStairCommitGate() {
+    let exited = false;
+    return {
+        shouldCommit: () => !exited,
+        markExited: () => {
+            exited = true;
+        },
+    };
+}
+/**
+ * Eat the one native browser `click` that follows a pointerup-synthesized
+ * node click, before it reaches the canvas `grid:click` listener (capture
+ * phase on window runs first). Needed in repeat continuation too, where the
+ * tool stays armed and the gate above must keep allowing one commit per
+ * gesture. Self-disarms after the click or `timeoutMs`, whichever first.
+ */
+export function swallowFollowUpBrowserClick(target = typeof window === 'undefined' ? undefined : window, timeoutMs = 300) {
+    if (!target)
+        return;
+    const swallow = (event) => {
+        event.stopPropagation();
+        event.preventDefault();
+    };
+    target.addEventListener('click', swallow, { capture: true, once: true });
+    setTimeout(() => target.removeEventListener('click', swallow, { capture: true }), timeoutMs);
+}

package/dist/stair/stair-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-type.d.ts","sourceRoot":"","sources":["../../src/stair/stair-type.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AAGzB,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAC3B,uFAAuF;IACvF,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAA;CACjC,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,eAAe,CAgBjB"}
+{"version":3,"file":"stair-type.d.ts","sourceRoot":"","sources":["../../src/stair/stair-type.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;IAC3B,uFAAuF;IACvF,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAA;CACjC,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,eAAe,CAgBjB"}

package/dist/stair/stair-type.js

@@ -1,5 +1,4 @@
-import { createStairFlightFromStair, } from '@pascal-app/core';
-import { DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE } from '@pascal-app/editor';
+import { createStairFlightFromStair, DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE, } from '@pascal-app/core';
 /**
  * Computes the stair patch for a type switch.
  *

package/dist/stair/surface-move-preview.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNodeId, type StairSurfaceSnap } from '@pascal-app/core';
+export declare function publishStairMovePreview(stairId: AnyNodeId, flightId: AnyNodeId | undefined, position: [number, number, number], rotation: number, snap: StairSurfaceSnap | null): void;
+export declare function clearStairMovePreview(stairId: AnyNodeId, flightId: AnyNodeId | undefined): void;
+//# sourceMappingURL=surface-move-preview.d.ts.map

package/dist/stair/surface-move-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-move-preview.d.ts","sourceRoot":"","sources":["../../src/stair/surface-move-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EAGtB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,gBAAgB,GAAG,IAAI,QAwC9B;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,QAOxF"}

package/dist/stair/surface-move-preview.js

@@ -0,0 +1,53 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+export function publishStairMovePreview(stairId, flightId, position, rotation, snap) {
+    const overrides = useLiveNodeOverrides.getState();
+    if (snap) {
+        overrides.setMany([
+            [
+                stairId,
+                {
+                    position,
+                    rotation,
+                    totalRise: snap.totalRise,
+                    stepCount: snap.stepCount,
+                    destinationSurfaceId: snap.surfaceId,
+                    railingMode: 'none',
+                },
+            ],
+            ...(flightId
+                ? [
+                    [
+                        flightId,
+                        { height: snap.totalRise, length: snap.length, stepCount: snap.stepCount },
+                    ],
+                ]
+                : []),
+        ]);
+        useScene.getState().markDirty(stairId);
+        if (flightId)
+            useScene.getState().markDirty(flightId);
+        return;
+    }
+    const hadSnap = overrides.get(stairId)?.totalRise !== undefined ||
+        (flightId !== undefined && overrides.get(flightId) !== undefined);
+    overrides.clearFields(stairId, ['totalRise', 'stepCount', 'railingMode']);
+    if (flightId && overrides.get(flightId))
+        overrides.clear(flightId);
+    overrides.set(stairId, { position, rotation, destinationSurfaceId: undefined });
+    if (hadSnap) {
+        useScene.getState().markDirty(stairId);
+        if (flightId)
+            useScene.getState().markDirty(flightId);
+    }
+}
+export function clearStairMovePreview(stairId, flightId) {
+    const overrides = useLiveNodeOverrides.getState();
+    if (!overrides.get(stairId) && (!flightId || !overrides.get(flightId)))
+        return;
+    overrides.clear(stairId);
+    if (flightId)
+        overrides.clear(flightId);
+    useScene.getState().markDirty(stairId);
+    if (flightId)
+        useScene.getState().markDirty(flightId);
+}

package/dist/stair/surface-transition.d.ts

@@ -0,0 +1,9 @@
+import { type AnyNode, type StairNode } from '@pascal-app/core';
+type Point = [number, number];
+export type TransitionProfile = {
+    frontZ: number;
+    samples: Point[];
+};
+export declare function surfaceTransitionProfile(stair: StairNode, surface: AnyNode, length: number): TransitionProfile | null;
+export {};
+//# sourceMappingURL=surface-transition.d.ts.map

package/dist/stair/surface-transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-transition.d.ts","sourceRoot":"","sources":["../../src/stair/surface-transition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAgB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE7E,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC7B,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AAEpE,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GACb,iBAAiB,GAAG,IAAI,CA2D1B"}

package/dist/stair/surface-transition.js

@@ -0,0 +1,61 @@
+import { nodeRegistry } from '@pascal-app/core';
+export function surfaceTransitionProfile(stair, surface, length) {
+    if (!Number.isFinite(length))
+        return null;
+    const boundary = nodeRegistry.get(surface.type)?.capabilities?.surfaces?.top?.boundary;
+    if (!boundary)
+        return null;
+    const surfaceOutline = boundary(surface, 0);
+    if (surfaceOutline.length < 3)
+        return null;
+    const pose = surface;
+    const surfacePosition = pose.position ?? [0, 0, 0];
+    const surfaceAngle = typeof pose.rotation === 'number' ? pose.rotation : (pose.rotation?.[1] ?? 0);
+    const attached = stair.parentId === stair.destinationSurfaceId;
+    const parentCos = Math.cos(surfaceAngle), parentSin = Math.sin(surfaceAngle);
+    const stairPosition = attached
+        ? [
+            surfacePosition[0] + parentCos * stair.position[0] + parentSin * stair.position[2],
+            surfacePosition[1] + stair.position[1],
+            surfacePosition[2] - parentSin * stair.position[0] + parentCos * stair.position[2],
+        ]
+        : stair.position;
+    const stairRotation = stair.rotation + (attached ? surfaceAngle : 0);
+    const cc = Math.cos(stairRotation), cs = Math.sin(stairRotation);
+    const highX = stairPosition[0] + cs * length;
+    const highZ = stairPosition[2] + cc * length;
+    const outline = surfaceOutline.map(([x, z]) => {
+        const dx = x - highX;
+        const dz = z - highZ;
+        return [dx * cc - dz * cs, dx * cs + dz * cc];
+    });
+    const halfWidth = stair.width / 2;
+    const samples = [];
+    const sampleXs = [
+        -halfWidth,
+        0,
+        halfWidth,
+        ...outline.map(([x]) => x).filter((x) => x > -halfWidth && x < halfWidth),
+    ]
+        .sort((a, b) => a - b)
+        .filter((x, index, values) => index === 0 || x - values[index - 1] > 1e-6);
+    for (const x of sampleXs) {
+        const crossings = [];
+        for (let edge = 0; edge < outline.length; edge++) {
+            const a = outline[edge], b = outline[(edge + 1) % outline.length];
+            const dx = b[0] - a[0];
+            if (Math.abs(dx) < 1e-8)
+                continue;
+            const t = (x - a[0]) / dx;
+            if (t >= 0 && t <= 1)
+                crossings.push(a[1] + (b[1] - a[1]) * t);
+        }
+        const boundary = crossings.sort((a, b) => Math.abs(a) - Math.abs(b))[0];
+        if (boundary === undefined || boundary < -0.12 || boundary > 0.7)
+            return null;
+        samples.push([x, boundary]);
+    }
+    if (samples.every(([, z]) => Math.abs(z) < 0.015))
+        return null;
+    return { frontZ: 0, samples };
+}

package/dist/stair/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/stair/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/stair/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;eAEjC,WAAW"}

package/dist/stair/tool.d.ts

@@ -0,0 +1,2 @@
+export default function StairTool(): import("react").JSX.Element;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/stair/tool.tsx"],"names":[],"mappings":"AA+TA,MAAM,CAAC,OAAO,UAAU,SAAS,gCA8dhC"}