@pascal-app/core 0.9.2 → 1.0.0-beta.2

package/dist/systems/elevator/elevator-opening-system.d.ts

@@ -1,2 +1,3 @@
+export declare function initializeElevatorOpeningSync(): () => void;
 export declare const ElevatorOpeningSystem: () => null;
 //# sourceMappingURL=elevator-opening-system.d.ts.map

package/dist/systems/elevator/elevator-opening-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,qBAAqB,YAuBjC,CAAA"}
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAmCA,wBAAgB,6BAA6B,eAsB5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}

package/dist/systems/elevator/elevator-opening-system.js

@@ -1,5 +1,6 @@
 'use client';
-import { useEffect, useRef } from 'react';
+import { useEffect } from 'react';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
 import useScene from '../../store/use-scene';
 import { syncAutoElevatorOpenings } from './elevator-opening-sync';
 function isOpeningRelevantNode(node) {
@@ -23,26 +24,31 @@ function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
     }
     return false;
 }
-export const ElevatorOpeningSystem = () => {
-    const syncingAutoOpeningsRef = useRef(false);
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
+export function initializeElevatorOpeningSync() {
+    let syncingAutoOpenings = false;
+    const applyUpdates = (updates) => {
+        if (updates.length === 0)
+            return;
+        syncingAutoOpenings = true;
+        pauseSceneHistory(useScene);
+        try {
             useScene.getState().updateNodes(updates);
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
-        return useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
-                return;
-            applyUpdates(syncAutoElevatorOpenings(state.nodes));
-        });
-    }, []);
+        }
+        finally {
+            resumeSceneHistory(useScene);
+            syncingAutoOpenings = false;
+        }
+    };
+    applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
+    return useScene.subscribe((state, prevState) => {
+        if (syncingAutoOpenings)
+            return;
+        if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+            return;
+        applyUpdates(syncAutoElevatorOpenings(state.nodes));
+    });
+}
+export const ElevatorOpeningSystem = () => {
+    useEffect(() => initializeElevatorOpeningSync(), []);
     return null;
 };

package/dist/systems/elevator/elevator-service.d.ts

@@ -1,5 +1,4 @@
 import type { AnyNode, ElevatorNode, LevelNode } from '../../schema';
-export declare const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
 export type ElevatorLevelEntry = {
     id: LevelNode['id'];
     label: string;
@@ -8,7 +7,6 @@ export type ElevatorLevelEntry = {
 export declare function resolveElevatorBuildingLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
 export declare function resolveElevatorServiceLevelIds(elevator: ElevatorNode, nodes: Record<string, AnyNode>): string[];
 export declare function resolveElevatorServiceLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
-export declare function getElevatorLevelHeight(levelId: string, nodes: Record<string, AnyNode>): number;
 export declare function resolveElevatorLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): {
     entries: ElevatorLevelEntry[];
     defaultEntry: ElevatorLevelEntry | null;

package/dist/systems/elevator/elevator-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAGP,YAAY,EACZ,SAAS,EAEV,MAAM,cAAc,CAAA;AAErB,eAAO,MAAM,6BAA6B,MAAM,CAAA;AAEhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAoB9F;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}
+{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}

package/dist/systems/elevator/elevator-service.js

@@ -1,4 +1,4 @@
-export const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+import { getStoredLevelHeight } from '../../services/storey';
 function getBuildingLevels(elevator, nodes) {
     const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
         ? nodes[elevator.parentId]
@@ -49,35 +49,13 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
     const maxIndex = Math.max(fromIndex, resolvedToIndex);
     return levels.slice(minIndex, maxIndex + 1);
 }
-export function getElevatorLevelHeight(levelId, nodes) {
-    const level = nodes[levelId];
-    if (level?.type !== 'level')
-        return DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-    let maxTop = 0;
-    for (const childId of level.children) {
-        const child = nodes[childId];
-        if (!child)
-            continue;
-        if (child.type === 'ceiling') {
-            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-            if (height > maxTop)
-                maxTop = height;
-        }
-        else if (child.type === 'wall') {
-            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-            if (height > maxTop)
-                maxTop = height;
-        }
-    }
-    return maxTop > 0 ? maxTop : DEFAULT_ELEVATOR_LEVEL_HEIGHT;
-}
 export function resolveElevatorLevels(elevator, nodes) {
     const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
     const baseYByLevelId = new Map();
     let cumulativeY = 0;
     for (const level of allLevels) {
         baseYByLevelId.set(level.id, cumulativeY);
-        cumulativeY += getElevatorLevelHeight(level.id, nodes);
+        cumulativeY += getStoredLevelHeight(level);
     }
     const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
     const entries = serviceLevels.map((level) => ({

package/dist/systems/slab/slab-placement.d.ts

@@ -0,0 +1,11 @@
+import type { SlabNode } from '../../schema';
+/**
+ * Translate a solid slab's authored vertical interval onto a chosen base plane.
+ *
+ * `slab.elevation` is the authored top relative to the placement plane and
+ * `thickness` grows downward. Adding the base therefore preserves both the
+ * thickness and any intentional clearance in a preset. Recessed slabs keep
+ * their level-relative depth because their rim is defined by the level plane.
+ */
+export declare function resolveSlabPlacementElevation(slab: Pick<SlabNode, 'elevation' | 'recessed'>, baseElevation: number | null | undefined): number;
+//# sourceMappingURL=slab-placement.d.ts.map

package/dist/systems/slab/slab-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-placement.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,CAAC,EAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,MAAM,CAKR"}

package/dist/systems/slab/slab-placement.js

@@ -0,0 +1,14 @@
+/**
+ * Translate a solid slab's authored vertical interval onto a chosen base plane.
+ *
+ * `slab.elevation` is the authored top relative to the placement plane and
+ * `thickness` grows downward. Adding the base therefore preserves both the
+ * thickness and any intentional clearance in a preset. Recessed slabs keep
+ * their level-relative depth because their rim is defined by the level plane.
+ */
+export function resolveSlabPlacementElevation(slab, baseElevation) {
+    if (slab.recessed || baseElevation == null || !Number.isFinite(baseElevation)) {
+        return slab.elevation;
+    }
+    return slab.elevation + baseElevation;
+}

package/dist/systems/slab/slab-support.d.ts

@@ -0,0 +1,150 @@
+import type { SlabNode, WallNode } from '../../schema';
+export type SlabElevationClamp = {
+    elevation: number;
+    clamped: boolean;
+};
+/**
+ * Clamp-never-ask upper bound for a slab's elevation. A plane-bound wall
+ * (no stored `height`) keeps its top at the storey plane, so a slab that
+ * rises past `storeyHeight - MIN_WALL_HEIGHT` while electing as that
+ * wall's base would squeeze the wall body below its minimum (and at the
+ * plane, to nothing). Walls with explicit heights don't constrain — their
+ * top rides the elected base, not the plane. Negative proposals (the
+ * drag-through-zero path that commits the `recessed` intent) pass
+ * through untouched: this is a purely numeric upper bound.
+ *
+ * The election runs against `levelSlabs` with `proposedElevation`
+ * substituted into `slab`, so a slab that would only WIN the election at
+ * the proposed elevation still clamps, and a slab out-elected by a
+ * sibling doesn't. Pure.
+ */
+export declare function clampSlabElevationForWalls(proposedElevation: number, slab: SlabNode, levelWalls: WallNode[], levelSlabs: readonly SlabNode[], storeyHeight: number): SlabElevationClamp;
+/**
+ * Static upper bound for a slab-elevation drag: probe the election with
+ * the slab raised above every sibling and the storey plane. If any
+ * plane-bound wall would elect it there, the drag may not pass
+ * `storeyHeight - MIN_WALL_HEIGHT`; otherwise it is unbounded above.
+ */
+export declare function getSlabElevationUpperBound(slab: SlabNode, levelWalls: WallNode[], levelSlabs: readonly SlabNode[], storeyHeight: number): number;
+/**
+ * Point-in-polygon test using ray casting algorithm.
+ */
+export declare function pointInPolygon(px: number, pz: number, polygon: Array<[number, number]>): boolean;
+export declare function pointOnPolygonBoundary(px: number, pz: number, polygon: Array<[number, number]>): boolean;
+export type WallOverlapInput = {
+    start: [number, number];
+    end: [number, number];
+    curveOffset?: number;
+    thickness?: number;
+};
+/**
+ * Test whether a wall overlaps a slab polygon along a segment of its length.
+ *
+ * The wall's centerline and both face lines are clipped against the polygon;
+ * the wall overlaps when the longest clipped inside-or-on-boundary length
+ * exceeds a threshold (5cm, halved for very short walls). Because interval
+ * midpoints classify "on the boundary" as inside explicitly (never by
+ * ray-cast tie-breaking), a wall sitting exactly on a slab edge resolves
+ * identically on every side of the slab.
+ *
+ * A wall that only touches the polygon at a point — a perpendicular wall
+ * butting into a room's edge, or a corner-to-corner touch — clips to ~zero
+ * length and does NOT overlap.
+ */
+export declare function wallOverlapsPolygon(startOrWall: [number, number] | WallOverlapInput, endOrPolygon: [number, number] | Array<[number, number]>, polygonArg?: Array<[number, number]>): boolean;
+/**
+ * {@link wallOverlapsPolygon} with the slab's stored holes subtracted from
+ * the covered length: a wall whose band only reaches the polygon inside a
+ * hole does not overlap. Hole boundaries keep coverage (rim convention —
+ * see {@link computeWallSlabSupport}). Polygon boundary contact counts as
+ * covered, so a wall sitting exactly on a slab edge resolves identically
+ * on every side of the slab. Pure.
+ */
+export declare function wallOverlapsSlabFootprint(wallLike: WallOverlapInput, polygon: Array<[number, number]>, holes?: ReadonlyArray<Array<[number, number]>>): boolean;
+/**
+ * Tolerance for the pointer-decided support cap: a slab still counts as
+ * "the surface you're pointing at (or below)" when its walking surface is
+ * within this many meters ABOVE the pointed elevation. Absorbs elevation
+ * noise between the ray hit and slab tops without letting a deck hanging
+ * clearly above the hit point capture the election. Defined here (rather
+ * than in the spatial-grid manager, which re-exports it) so the wall
+ * election below can honour the same cap without an import cycle.
+ */
+export declare const SUPPORT_ELEVATION_EPSILON = 0.05;
+/**
+ * Base elevation for a wall, decided by which slabs actually SUPPORT it.
+ *
+ * Support is measured as covered length: the wall's centerline and face
+ * lines are clipped against each slab's RENDERED footprint
+ * (`getRenderableSlabPolygon` with the level walls + siblings, not the
+ * stored polygon — legacy polygons stored at wall faces or with old
+ * baked offsets fall short of the wall body, but their band-adopted
+ * rendered edge reaches the wall's outer face) minus the slab's stored
+ * holes (holes are data, never render-offset). A slab supporting less
+ * than `WALL_SLAB_MIN_OVERLAP` of the wall is ignored entirely (point
+ * contact, endpoint grazes).
+ *
+ * Same-elevation slabs pool their coverage. `elevation` is elected from
+ * the wall's carrying profile: per arc segment, the highest support on
+ * each face, then the min across supported faces — so a slab that only
+ * brushes one face (e.g. an elevated deck adjacent along the outer face)
+ * never lifts the wall origin. The highest carrying elevation covering
+ * at least `WALL_SLAB_SUPPORT_MAJORITY` of the wall wins, or the
+ * best-covered carrying elevation when none reaches majority.
+ * `baseElevation` only fills down
+ * where a lower support remains exposed on a wall face after higher,
+ * overlapping support is accounted for. Coincident floor/platform slabs
+ * therefore keep the wall on the platform, while slabs on opposite wall
+ * sides bridge correctly. A slab touching only one endpoint never enters
+ * either result. Pure;
+ * exported for tests.
+ */
+export type WallSlabSupport = {
+    /** Existing wall-relative floor elevation used by hosted children and wall height. */
+    elevation: number;
+    /** Slab whose elevation won the election, or null when the wall has no support. */
+    electedSlabId: string | null;
+    /** Lowest exposed adjacent support; wall geometry fills down to this elevation. */
+    baseElevation: number;
+    /** Piecewise bottom elevation along the wall centerline, in normalized arc-length units. */
+    baseSegments: WallSlabSupportSegment[];
+};
+export type WallSlabSupportSegment = {
+    start: number;
+    end: number;
+    elevation: number;
+};
+/**
+ * `preferredSlabId` is a persisted support host (`wall.supportSlabId`):
+ * while that slab is still in the candidate set (still overlaps the wall
+ * band with enough covered length), the elected `elevation` is pinned to
+ * it instead of the majority/best-coverage election. `baseSegments` /
+ * `baseElevation` (fill-down) still derive from ALL supporting slabs
+ * unchanged. A preferred slab that no longer qualifies is silently
+ * ignored — deliberately never cleared here, so the host resumes if the
+ * slab's polygon returns (only slab deletion strips the stored field).
+ *
+ * `maxElevation` is the pointer-decided support cap (level-local Y, same
+ * semantics as the item election): when set, elevation groups whose
+ * walking surface sits above `maxElevation + SUPPORT_ELEVATION_EPSILON`
+ * are excluded from the majority/best election — a deck hanging above the
+ * surface the cursor ray actually hit never captures the elected base.
+ * `baseSegments` / `baseElevation` stay uncapped (geometry fill-down), and
+ * an explicit `preferredSlabId` still wins over the cap.
+ *
+ * `levelBase` is what "no slab supports this here" evaluates to — the
+ * sculpted ground under the wall (`levelBaseElevationAt`), or 0 for a level
+ * with no terrain under it. A caller-resolved scalar rather than a terrain
+ * lookup in here, so this stays pure and the sample stays at the wall's own
+ * XZ. It substitutes for every place this function used to write a literal
+ * `0`, and nowhere else: a slab that supports the wall's faces still wins
+ * outright, so a slab pad on a hillside keeps its wall at the pad's
+ * elevation instead of being overruled by the ground around it. The one
+ * clamp — center-only support, where the old code already clamped a
+ * recessed slab up to `0` so a wall over a pool didn't sink — generalizes to
+ * "never below the ground", which is the same rule with the ground no longer
+ * assumed flat.
+ */
+export declare function computeWallSlabSupport(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[], preferredSlabId?: string | null, maxElevation?: number | null, levelBase?: number): WallSlabSupport;
+export declare function computeWallSlabElevation(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[]): number;
+//# sourceMappingURL=slab-support.d.ts.map

package/dist/systems/slab/slab-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slab-support.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-support.ts"],"names":[],"mappings":"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"}