@pascal-app/core 1.0.3 → 1.0.5

package/dist/systems/stair/stair-rise-query.js

@@ -0,0 +1,175 @@
+import { containsPoint } from '../../lib/polygon-boolean.js';
+import { StairDesignTargets } from '../../schema/nodes/stair-design-targets.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
+import { findLevelAboveId, getLevelElevations, getLevelFloorToFloorHeight, } from '../../services/storey.js';
+import { stairBaseElevation } from './stair-base-elevation.js';
+import { stairArrivalOpening } from './stair-footprint.js';
+/** The level a stair rises from: the one it names, else the one holding it. */
+function stairSourceLevel(stair, nodes) {
+    const requested = stair.fromLevelId ? nodes[stair.fromLevelId] : undefined;
+    if (requested?.type === 'level')
+        return requested;
+    const parent = stair.parentId ? nodes[stair.parentId] : undefined;
+    if (parent?.type === 'level')
+        return parent;
+    return Object.values(nodes).find((node) => node.type === 'level' && (node.children ?? []).includes(stair.id));
+}
+export function resolveStairTotalRise(stair, nodes, baseElevationFor = stairBaseElevation, legacyArrival = false) {
+    if (stair.totalRise !== undefined)
+        return stair.totalRise;
+    const level = stairSourceLevel(stair, nodes);
+    // Both destinations are absolute level-local heights, while the stair's own
+    // base may be lifted onto a floor slab by the floor-stack
+    // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
+    // `position[1] + elected slab elevation`). The rise is measured from that
+    // base, so subtract it — electing the base exactly the way the visual
+    // systems do (persisted `supportSlabId` honored, uncapped election
+    // otherwise) keeps base + rise landing precisely on the destination surface.
+    const baseElevation = baseElevationFor(stair, nodes, level?.id ?? null);
+    if (stair.deckSlabId) {
+        // The deck's `elevation` IS its walking surface (level-local). A stale
+        // reference (deck gone) falls through to the level-derived rise.
+        const deck = nodes[stair.deckSlabId];
+        if (deck?.type === 'slab')
+            return (deck.elevation ?? 0.05) - baseElevation;
+    }
+    if (!level)
+        return DEFAULT_LEVEL_HEIGHT;
+    if (legacyArrival)
+        return getLevelFloorToFloorHeight(level.id, nodes) - baseElevation;
+    const elevations = getLevelElevations(nodes);
+    const requestedDestination = stair.toLevelId ? elevations.get(stair.toLevelId) : undefined;
+    const sourceElevation = elevations.get(level.id);
+    const destinationId = requestedDestination &&
+        sourceElevation &&
+        requestedDestination.buildingId === sourceElevation.buildingId &&
+        requestedDestination.ordinal > sourceElevation.ordinal
+        ? stair.toLevelId
+        : findLevelAboveId(level.id, elevations);
+    if (!destinationId)
+        return getLevelFloorToFloorHeight(level.id, nodes) - baseElevation;
+    const opening = stairArrivalOpening(stair, nodes);
+    const point = opening.length
+        ? [
+            opening.reduce((sum, vertex) => sum + vertex[0], 0) / opening.length,
+            opening.reduce((sum, vertex) => sum + vertex[1], 0) / opening.length,
+        ]
+        : [stair.position[0], stair.position[2]];
+    const covers = (polygon, holes) => containsPoint([{ outer: polygon, holes }], point);
+    const room = Object.values(nodes).find((node) => node.type === 'zone' &&
+        node.parentId === destinationId &&
+        node.spaceRole === 'room' &&
+        node.enclosureStatus !== 'open' &&
+        node.hasFloor !== false &&
+        node.floor?.support !== 'open' &&
+        node.floor?.elevation !== undefined &&
+        covers(node.polygon, node.holes ?? []));
+    const plate = Object.values(nodes).find((node) => node.type === 'slab' &&
+        node.parentId === destinationId &&
+        node.plateRole === 'base' &&
+        covers(node.polygon, []));
+    const top = room?.type === 'zone' ? room.floor.elevation : plate?.type === 'slab' ? plate.elevation : 0;
+    return (elevations.get(destinationId).baseY - elevations.get(level.id).baseY + top - baseElevation);
+}
+const RISE_SYNC_EPSILON = 1e-4;
+/**
+ * Keeps straight stairs' flight segments in step with the resolved rise.
+ * Straight-stair geometry derives from per-segment heights (not from
+ * `resolveStairTotalRise`), so level-height and deck-elevation changes must
+ * write through to the flight segments — curved/spiral stairs read the
+ * resolved rise directly and need no sync.
+ *
+ * Scope: stairs whose total the system owns — follows-mode stairs (absent
+ * `totalRise`, tracking their level or their deck) and deck-attached stairs
+ * (an explicit rise converges to the typed value). A detached stair with an
+ * explicit `totalRise` keeps its hand-edited segment chain, unless the user
+ * enabled uniform risers. Flight heights otherwise scale proportionally
+ * (landings keep theirs); returns `updateNodes` patches, empty when every
+ * stair is already in step.
+ */
+export function syncStairRises(nodes, baseElevationFor = stairBaseElevation, legacyArrival = false) {
+    const updates = [];
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'stair' || (node.stairType ?? 'straight') !== 'straight')
+            continue;
+        const deck = node.deckSlabId ? nodes[node.deckSlabId] : undefined;
+        if (node.totalRise !== undefined && deck?.type !== 'slab' && !node.uniformRisers)
+            continue;
+        const segments = (node.children ?? [])
+            .map((childId) => nodes[childId])
+            .filter((child) => child?.type === 'stair-segment');
+        const flights = segments.filter((segment) => segment.segmentType === 'stair');
+        if (flights.length === 0)
+            continue;
+        const landingRise = segments
+            .filter((segment) => segment.segmentType !== 'stair')
+            .reduce((sum, segment) => sum + segment.height, 0);
+        const flightRise = flights.reduce((sum, segment) => sum + segment.height, 0);
+        const targetFlightRise = resolveStairTotalRise(node, nodes, baseElevationFor, legacyArrival) - landingRise;
+        if (!Number.isFinite(targetFlightRise) || targetFlightRise <= 0)
+            continue;
+        if (!node.uniformRisers && Math.abs(flightRise - targetFlightRise) <= RISE_SYNC_EPSILON)
+            continue;
+        const count = flights.reduce((sum, flight) => sum + Math.max(0, flight.stepCount), 0);
+        for (const flight of flights) {
+            // A sole flight owns the exact target; proportional scaling adds undo/redo rounding drift.
+            const height = flights.length === 1
+                ? targetFlightRise
+                : node.uniformRisers && count > 0
+                    ? (targetFlightRise * Math.max(0, flight.stepCount)) / count
+                    : flightRise > RISE_SYNC_EPSILON
+                        ? flight.height * (targetFlightRise / flightRise)
+                        : targetFlightRise / flights.length;
+            if (Math.abs(height - flight.height) > RISE_SYNC_EPSILON)
+                updates.push({ id: flight.id, data: { height } });
+        }
+    }
+    return updates;
+}
+export function stairHasNoRise(stair, nodes) {
+    return resolveStairTotalRise(stair, nodes) <= 0;
+}
+/**
+ * Steps that stand on a storey without climbing to another: a flight onto a deck, or a flight to
+ * no level, one naming the level it rises from and none it arrives on (create_stair's
+ * `toLevelId: null`: porch, deck or garden steps), whatever its rise.
+ */
+export function stairClimbsToNoStorey(stair, nodes) {
+    if (stair.deckSlabId && nodes[stair.deckSlabId]?.type === 'slab')
+        return true;
+    return !!stair.fromLevelId && !stair.toLevelId;
+}
+/**
+ * Whether a stair climbs to the storey above the one it rises from: what verify_scene and the
+ * hosts' checks count as a way upstairs. Steps that climb to no storey do not; a stair naming a
+ * level above does. Otherwise, with a storey above, a stair that follows its storey (no
+ * `totalRise`) reaches it, and one keeping a rise of its own (an Architect add_stair flight, an
+ * editor stair given a custom rise) does when that rise is within a riser of the floor-to-floor
+ * height. A declared roof level is no storey (`isRoofLevel`, read here without the registry
+ * roof-level.ts loads, which the hosts' checks must not).
+ */
+export function stairReachesStoreyAbove(stair, nodes) {
+    if (stairClimbsToNoStorey(stair, nodes))
+        return false;
+    const level = stairSourceLevel(stair, nodes);
+    if (!level)
+        return false;
+    const elevations = getLevelElevations(nodes);
+    const storey = (id) => {
+        const node = id ? nodes[id] : undefined;
+        return node?.type === 'level' && node.metadata?.role !== 'roof'
+            ? elevations.get(node.id)
+            : undefined;
+    };
+    const source = elevations.get(level.id);
+    const named = storey(stair.toLevelId);
+    if (source && named && named.buildingId === source.buildingId && named.ordinal > source.ordinal)
+        return true;
+    const above = storey(findLevelAboveId(level.id, elevations));
+    if (!(source && above))
+        return false;
+    if (stair.totalRise === undefined)
+        return true;
+    const riser = StairDesignTargets.parse(stair.designTargets ?? {}).maxRiserHeight;
+    return Math.abs(stair.totalRise - (above.baseY - source.baseY)) < riser;
+}

package/dist/systems/stair/stair-rise.d.ts

@@ -1,22 +1,7 @@
-import type { AnyNode, AnyNodeId, StairNode } from '../../schema/index.js';
+import type { AnyNode, StairNode } from '../../schema/index.js';
 export declare function resolveStairTotalRise(stair: StairNode, nodes: Record<string, AnyNode>): number;
-/**
- * Keeps straight stairs' flight segments in step with the resolved rise.
- * Straight-stair geometry derives from per-segment heights (not from
- * `resolveStairTotalRise`), so level-height and deck-elevation changes must
- * write through to the flight segments — curved/spiral stairs read the
- * resolved rise directly and need no sync.
- *
- * Scope: stairs whose total the system owns — follows-mode stairs (absent
- * `totalRise`, tracking their level or their deck) and deck-attached stairs
- * (an explicit rise converges to the typed value). A detached stair with an
- * explicit `totalRise` is the one place hand-edited segment chains are
- * legitimate, so it is never touched. Flight heights scale proportionally
- * (landings keep theirs); returns `updateNodes` patches, empty when every
- * stair is already in step.
- */
-export declare function syncStairRises(nodes: Record<string, AnyNode>): Array<{
-    id: AnyNodeId;
+export declare function syncStairRises(nodes: Record<string, AnyNode>): {
+    id: import("../../index.js").AnyNodeId;
     data: Partial<AnyNode>;
-}>;
+}[];
 //# sourceMappingURL=stair-rise.d.ts.map

package/dist/systems/stair/stair-rise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA+B9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}
+{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAoBtD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAErF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;IAE5D"}

package/dist/systems/stair/stair-rise.js

@@ -1,80 +1,17 @@
 import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation.js';
-import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
-import { getLevelFloorToFloorHeight } from '../../services/storey.js';
-export function resolveStairTotalRise(stair, nodes) {
-    if (stair.totalRise !== undefined)
-        return stair.totalRise;
-    const level = Object.values(nodes).find((node) => node.type === 'level' && node.children.includes(stair.id));
-    // Both destinations are absolute level-local heights, while the stair's own
-    // base may be lifted onto a floor slab by the floor-stack
-    // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
-    // `position[1] + elected slab elevation`). The rise is measured from that
-    // base, so subtract it — electing the base exactly the way the visual
-    // systems do (persisted `supportSlabId` honored, uncapped election
-    // otherwise) keeps base + rise landing precisely on the destination surface.
-    const baseElevation = getFloorStackedPosition({
+import { resolveStairTotalRise as resolveRise, syncStairRises as syncRises, } from './stair-rise-query.js';
+function liveBaseElevation(stair, nodes, levelId) {
+    return getFloorStackedPosition({
         node: stair,
         nodes,
         position: stair.position,
         rotation: stair.rotation,
-        levelId: level?.id ?? null,
+        levelId,
     })[1];
-    if (stair.deckSlabId) {
-        // The deck's `elevation` IS its walking surface (level-local). A stale
-        // reference (deck gone) falls through to the level-derived rise.
-        const deck = nodes[stair.deckSlabId];
-        if (deck?.type === 'slab')
-            return (deck.elevation ?? 0.05) - baseElevation;
-    }
-    if (level?.type !== 'level')
-        return DEFAULT_LEVEL_HEIGHT;
-    return getLevelFloorToFloorHeight(level.id, nodes) - baseElevation;
 }
-const RISE_SYNC_EPSILON = 1e-4;
-/**
- * Keeps straight stairs' flight segments in step with the resolved rise.
- * Straight-stair geometry derives from per-segment heights (not from
- * `resolveStairTotalRise`), so level-height and deck-elevation changes must
- * write through to the flight segments — curved/spiral stairs read the
- * resolved rise directly and need no sync.
- *
- * Scope: stairs whose total the system owns — follows-mode stairs (absent
- * `totalRise`, tracking their level or their deck) and deck-attached stairs
- * (an explicit rise converges to the typed value). A detached stair with an
- * explicit `totalRise` is the one place hand-edited segment chains are
- * legitimate, so it is never touched. Flight heights scale proportionally
- * (landings keep theirs); returns `updateNodes` patches, empty when every
- * stair is already in step.
- */
+export function resolveStairTotalRise(stair, nodes) {
+    return resolveRise(stair, nodes, liveBaseElevation);
+}
 export function syncStairRises(nodes) {
-    const updates = [];
-    for (const node of Object.values(nodes)) {
-        if (node.type !== 'stair' || node.stairType !== 'straight')
-            continue;
-        const deck = node.deckSlabId ? nodes[node.deckSlabId] : undefined;
-        if (node.totalRise !== undefined && deck?.type !== 'slab')
-            continue;
-        const segments = (node.children ?? [])
-            .map((childId) => nodes[childId])
-            .filter((child) => child?.type === 'stair-segment');
-        const flights = segments.filter((segment) => segment.segmentType === 'stair');
-        if (flights.length === 0)
-            continue;
-        const landingRise = segments
-            .filter((segment) => segment.segmentType !== 'stair')
-            .reduce((sum, segment) => sum + segment.height, 0);
-        const flightRise = flights.reduce((sum, segment) => sum + segment.height, 0);
-        const targetFlightRise = resolveStairTotalRise(node, nodes) - landingRise;
-        if (targetFlightRise <= 0)
-            continue;
-        if (Math.abs(flightRise - targetFlightRise) <= RISE_SYNC_EPSILON)
-            continue;
-        for (const flight of flights) {
-            const height = flightRise > RISE_SYNC_EPSILON
-                ? flight.height * (targetFlightRise / flightRise)
-                : targetFlightRise / flights.length;
-            updates.push({ id: flight.id, data: { height } });
-        }
-    }
-    return updates;
+    return syncRises(nodes, liveBaseElevation);
 }