@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/room-floor-feasibility.js

@@ -0,0 +1,293 @@
+import { boundaries, roomFace } from '../commands/structure/shared.js';
+import { DEFAULT_SLAB_ELEVATION, MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS, } from '../schema/nodes/slab.js';
+import { getStoredLevelHeight, getWallTop } from '../services/storey.js';
+import { getWallCurveFrameAt, getWallCurveLength } from '../systems/wall/wall-curve.js';
+import { MIN_WALL_HEIGHT } from '../systems/wall/wall-top.js';
+import { floorPlateHoldsUnderside, footprintLift } from './floor-foundation-datum.js';
+import { isFloorAnchoredOpening } from './floor-opening-footprints.js';
+import { floorRoomFaces } from './floor-room-faces.js';
+import { getOpeningFloorTarget, openingFitsAtDatum, supportSegmentAt, wallSupportForNodes, } from './opening-floor-datum.js';
+import { area, intersection, union } from './polygon-boolean.js';
+import { autoRoomVerticalPlacements } from './room-vertical-placement.js';
+export const FLOOR_ELEVATION_EPSILON = 0.001;
+export { MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS };
+const roomBaseMemo = new WeakMap();
+export function getRoomBaseElevation(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    const levelId = zone?.parentId;
+    if (!levelId)
+        return DEFAULT_SLAB_ELEVATION;
+    const plate = Object.values(nodes).find((node) => node.type === 'slab' &&
+        node.plateRole === 'base' &&
+        !!node.zoneIds?.includes(zoneId));
+    if (plate)
+        return plate.floorHeight ?? plate.elevation;
+    if (zone?.type !== 'zone' ||
+        zone.spaceRole !== 'room' ||
+        zone.hasFloor === false ||
+        zone.enclosureStatus === 'open' ||
+        zone.floor?.support === 'open')
+        return DEFAULT_SLAB_ELEVATION;
+    let cache = roomBaseMemo.get(nodes);
+    if (!cache) {
+        cache = new Map();
+        roomBaseMemo.set(nodes, cache);
+    }
+    const cached = cache.get(zoneId);
+    if (cached !== undefined)
+        return cached;
+    const face = roomFace(nodes, zone, floorRoomFaces(boundaries(nodes, levelId)));
+    if (!face)
+        return DEFAULT_SLAB_ELEVATION;
+    const polygon = { outer: face.referencePolygon, holes: face.holes };
+    const covered = union(Object.values(nodes).flatMap((node) => node.type === 'slab' &&
+        node.parentId === levelId &&
+        !node.autoFromWalls &&
+        node.boundary !== 'auto'
+        ? intersection(polygon, { outer: node.polygon, holes: node.holes })
+        : []));
+    const elevation = area(covered) >= area([polygon]) * 0.6
+        ? DEFAULT_SLAB_ELEVATION
+        : (autoRoomVerticalPlacements([{ ...face, zone }], nodes).get(zone.id) ??
+            DEFAULT_SLAB_ELEVATION);
+    cache.set(zoneId, elevation);
+    return elevation;
+}
+const automaticBaseMemo = new Map();
+export function automaticRoomBaseElevations(nodes, levelId) {
+    const signature = JSON.stringify([
+        levelId,
+        Object.values(nodes)
+            .filter((node) => node.type === 'site' ||
+            node.type === 'building' ||
+            node.type === 'level' ||
+            (node.parentId === levelId &&
+                (node.type === 'wall' ||
+                    node.type === 'separator' ||
+                    node.type === 'zone' ||
+                    (node.type === 'slab' && !node.autoFromWalls && node.boundary !== 'auto'))))
+            .map((node) => node.type === 'zone'
+            ? {
+                id: node.id,
+                type: node.type,
+                parentId: node.parentId,
+                polygon: node.polygon,
+                holes: node.holes,
+                seed: node.seed,
+                spaceRole: node.spaceRole,
+                hasFloor: node.hasFloor,
+                enclosureStatus: node.enclosureStatus,
+                support: node.floor?.support,
+                boundaryWallIds: node.boundaryWallIds,
+                boundarySeparatorIds: node.boundarySeparatorIds,
+            }
+            : node),
+    ]);
+    const hit = automaticBaseMemo.get(signature);
+    if (hit)
+        return hit;
+    const faces = floorRoomFaces(boundaries(nodes, levelId));
+    const manual = union(Object.values(nodes).flatMap((node) => node.type === 'slab' &&
+        node.parentId === levelId &&
+        node.boundary !== 'auto' &&
+        !node.autoFromWalls
+        ? [{ outer: node.polygon, holes: node.holes }]
+        : []));
+    const rooms = Object.values(nodes).flatMap((zone) => {
+        if (zone.type !== 'zone' ||
+            zone.parentId !== levelId ||
+            zone.spaceRole !== 'room' ||
+            zone.hasFloor === false ||
+            zone.enclosureStatus === 'open' ||
+            zone.floor?.support === 'open')
+            return [];
+        const face = roomFace(nodes, zone, faces);
+        if (!face)
+            return [];
+        const polygon = { outer: face.referencePolygon, holes: face.holes };
+        return area(intersection(polygon, manual)) >= area([polygon]) * 0.6
+            ? []
+            : [{ ...face, id: zone.id, polygon: face.referencePolygon, zone }];
+    });
+    const placements = autoRoomVerticalPlacements(rooms, nodes);
+    if (automaticBaseMemo.size >= 32)
+        automaticBaseMemo.delete(automaticBaseMemo.keys().next().value);
+    automaticBaseMemo.set(signature, placements);
+    return placements;
+}
+const feasibilityMemo = new WeakMap();
+export function checkRoomFloor(nodes, zoneId, proposedElevation) {
+    let cache = feasibilityMemo.get(nodes);
+    if (!cache) {
+        cache = new Map();
+        feasibilityMemo.set(nodes, cache);
+    }
+    const key = `${zoneId}:${proposedElevation}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    const result = computeRoomFloor(nodes, zoneId, proposedElevation);
+    cache.set(key, result);
+    return result;
+}
+function computeRoomFloor(nodes, zoneId, proposedElevation) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone')
+        throw new Error(`Room not found: ${zoneId}`);
+    const level = nodes[zone.parentId];
+    if (level?.type !== 'level')
+        throw new Error(`Level not found: ${zone.parentId}`);
+    const candidate = (zone.floor?.elevation ?? getRoomBaseElevation(nodes, zoneId)) === proposedElevation
+        ? nodes
+        : {
+            ...nodes,
+            [zoneId]: { ...zone, floor: { ...zone.floor, elevation: proposedElevation } },
+        };
+    const linked = zone.boundaryWallIds?.length ? new Set(zone.boundaryWallIds) : undefined;
+    const spans = linked
+        ? []
+        : (roomFace(nodes, zone, floorRoomFaces(boundaries(nodes, zone.parentId)))?.spans ?? []);
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' &&
+        (linked?.has(node.id) ?? spans.some((span) => span.boundaryId === node.id)));
+    const conflicts = [];
+    const hints = [];
+    let ceiling = getStoredLevelHeight(level);
+    let minElevation = Number.NEGATIVE_INFINITY;
+    let maxElevation = getStoredLevelHeight(level) - MIN_WALL_HEIGHT;
+    const base = Object.values(nodes).find((node) => node.type === 'slab' &&
+        node.parentId === level.id &&
+        node.plateRole === 'base' &&
+        !!node.zoneIds?.includes(zone.id));
+    const lift = base ? footprintLift(nodes, base) : 0;
+    ceiling += lift;
+    maxElevation += lift;
+    if (zone.floor?.support !== 'open' && base && floorPlateHoldsUnderside(nodes, base)) {
+        minElevation =
+            getRoomBaseElevation(nodes, zoneId) - (base?.thickness ?? 0.05) + MIN_SLAB_THICKNESS;
+        if (proposedElevation < minElevation - 1e-9)
+            conflicts.push({
+                code: 'floor-sunken-depth',
+                excess: minElevation - proposedElevation,
+                nodeIds: [zoneId, ...(base ? [base.id] : [])],
+                severity: 'error',
+                message: `Floor must be at least ${roundFloorElevation(minElevation)} m to retain the level soffit.`,
+            });
+    }
+    for (const wall of walls) {
+        const hasOpenings = wall.children.some((id) => nodes[id]?.type === 'door' || nodes[id]?.type === 'window');
+        const support = hasOpenings || wall.height !== undefined ? wallSupportForNodes(wall, candidate) : undefined;
+        const top = getWallTop(wall, level.id, nodes, support?.elevation ?? 0);
+        const openingSpans = hasOpenings && linked
+            ? (roomFace(nodes, zone, floorRoomFaces(boundaries(nodes, zone.parentId)))?.spans ?? [])
+            : spans;
+        maxElevation = Math.min(maxElevation, top - MIN_WALL_HEIGHT);
+        ceiling = Math.min(ceiling, top);
+        const length = getWallCurveLength(wall);
+        for (const id of wall.children) {
+            const opening = nodes[id];
+            if (opening?.type !== 'door' && opening?.type !== 'window')
+                continue;
+            const chord = (distance) => {
+                const point = getWallCurveFrameAt(wall, distance / length).point;
+                const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+                return (((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dz) / (dx * dx + dz * dz));
+            };
+            const from = chord(opening.position[0] - opening.width / 2), to = chord(opening.position[0] + opening.width / 2);
+            if (!openingSpans.some((span) => span.boundaryId === wall.id && Math.min(to, span.t1) > Math.max(from, span.t0)))
+                continue;
+            const datum = getOpeningFloorTarget(wall, opening, candidate);
+            const bottom = opening.position[1] - opening.height / 2;
+            if (isFloorAnchoredOpening(opening)) {
+                if (opening.type === 'door') {
+                    const from = Math.max(0, (opening.position[0] - opening.width / 2) / length);
+                    const to = Math.min(1, (opening.position[0] + opening.width / 2) / length);
+                    const floors = (face) => support.faceDatum[face].flatMap((run) => {
+                        const start = Math.max(from, run.start), end = Math.min(to, run.end);
+                        return end > start ? [supportSegmentAt(run, start), supportSegmentAt(run, end)] : [];
+                    });
+                    const lower = Math.min(datum, ...floors('a'), ...floors('b'));
+                    if (datum - lower > 0.2 + 1e-9)
+                        hints.push({
+                            code: 'floor-door-step',
+                            nodeIds: [zoneId, id],
+                            severity: 'warning',
+                            message: 'The doorway step exceeds 20 cm and needs steps.',
+                        });
+                    const swingsToA = (opening.swingDirection === 'inward') === Math.cos(opening.rotation[1]) >= 0;
+                    if (['hinged', 'double', 'french'].includes(opening.doorType) &&
+                        datum - Math.min(datum, ...floors(swingsToA ? 'a' : 'b')) > 0.02 + 1e-9)
+                        hints.push({
+                            code: 'floor-door-swing',
+                            nodeIds: [zoneId, id],
+                            severity: 'warning',
+                            message: 'The door swings toward the lower floor across a step.',
+                        });
+                }
+                const limit = top - opening.position[1] - opening.height / 2;
+                maxElevation = Math.min(maxElevation, limit);
+                if (!openingFitsAtDatum(wall, opening, datum, candidate, support))
+                    conflicts.push({
+                        code: 'floor-opening-fit',
+                        excess: datum + opening.position[1] + opening.height / 2 - top,
+                        nodeIds: [zoneId, id],
+                        severity: 'error',
+                        message: `Floor must be at most ${roundFloorElevation(limit)} m for ${opening.name || opening.type} to fit.`,
+                    });
+            }
+            else if (datum + bottom < proposedElevation - FLOOR_ELEVATION_EPSILON)
+                conflicts.push({
+                    code: 'floor-window-sill',
+                    nodeIds: [zoneId, id],
+                    severity: 'warning',
+                    message: 'The opening sill is below the room floor.',
+                });
+        }
+    }
+    if (proposedElevation > maxElevation + 1e-9 &&
+        !conflicts.some((c) => c.code === 'floor-opening-fit'))
+        conflicts.push({
+            code: 'floor-headroom',
+            excess: proposedElevation - maxElevation,
+            nodeIds: [zoneId],
+            severity: 'error',
+            message: `Floor must be at most ${roundFloorElevation(maxElevation)} m to retain minimum headroom.`,
+        });
+    if (ceiling - proposedElevation < 2.1 - 1e-9)
+        hints.push({
+            code: 'floor-low-headroom',
+            nodeIds: [zoneId],
+            severity: 'warning',
+            message: 'Headroom is below 2.10 m.',
+        });
+    conflicts.push(...hints);
+    const elevation = Math.max(minElevation, Math.min(maxElevation, proposedElevation));
+    return {
+        conflicts,
+        minElevation,
+        maxElevation,
+        elevation,
+        clamped: elevation !== proposedElevation,
+    };
+}
+export function roundFloorElevation(elevation) {
+    return Math.round(elevation * 1e6) / 1e6;
+}
+export function getRoomRelativeFloorElevation(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    return roundFloorElevation(((zone?.type === 'zone' ? zone.floor?.elevation : undefined) ??
+        getRoomBaseElevation(nodes, zoneId)) - getRoomBaseElevation(nodes, zoneId));
+}
+export function roomFloorElevationFromRelative(nodes, zoneId, height) {
+    return roundFloorElevation(getRoomBaseElevation(nodes, zoneId) + height);
+}
+export function clampRoomFloorHandle(nodes, zoneId, proposed) {
+    const check = checkRoomFloor(nodes, zoneId, proposed);
+    const zone = nodes[zoneId];
+    const current = zone?.type === 'zone'
+        ? (zone.floor?.elevation ?? getRoomBaseElevation(nodes, zoneId))
+        : proposed;
+    // Existing overloads may improve incrementally without snapping to another floor.
+    const max = Math.max(current, Math.floor((check.maxElevation + 1e-9) / 0.05) * 0.05);
+    const min = Math.min(current, Math.ceil((check.minElevation - 1e-9) / 0.05) * 0.05);
+    return roundFloorElevation(Math.max(min, Math.min(max, proposed)));
+}

package/dist/lib/room-floor-plate.d.ts

@@ -0,0 +1,3 @@
+import type { SlabNode } from '../schema/index.js';
+export declare function roomFloorPlate(slabs: readonly SlabNode[], zoneId: string): SlabNode | undefined;
+//# sourceMappingURL=room-floor-plate.d.ts.map

package/dist/lib/room-floor-plate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-floor-plate.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-plate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAG/F"}

package/dist/lib/room-floor-plate.js

@@ -0,0 +1,4 @@
+export function roomFloorPlate(slabs, zoneId) {
+    const owned = slabs.filter((slab) => slab.zoneIds?.includes(zoneId));
+    return owned.find((slab) => slab.plateRole !== 'base') ?? owned[0];
+}

package/dist/lib/room-graph.d.ts

@@ -0,0 +1,79 @@
+import type { AnyNode, SeparatorNode, WallNode } from '../schema/index.js';
+import { type Ring } from './polygon-boolean.js';
+import type { BoundaryNode, BoundarySpan } from './room-topology-index.js';
+export type Point2D = {
+    x: number;
+    y: number;
+};
+export type OpenWallEnd = {
+    wallId: string;
+    end: 'start' | 'end';
+    point: [number, number];
+    reason: 'gap' | 'crosses' | 'parallel' | 'rejected' | 'isolated';
+    gap?: number;
+    candidate?: {
+        wallId: string;
+        point: [number, number];
+        kind: 'endpoint' | 'body';
+    };
+};
+export type SpaceBoundaryFace = {
+    wallId: WallNode['id'];
+    face: 'front' | 'back';
+    points: Array<[number, number]>;
+};
+export type ExtractedRoom = {
+    id: string;
+    referencePolygon: Array<[number, number]>;
+    holes: Array<Array<[number, number]>>;
+    spans: BoundarySpan[];
+    polygon: Point2D[];
+    boundaryFaces: SpaceBoundaryFace[];
+};
+export declare const WALL_JUNCTION_TOLERANCE = 0.08;
+export declare function pointFromTuple(point: [number, number]): Point2D;
+export declare function pointToTuple(point: Point2D): [number, number];
+export declare function polygonArea(points: Point2D[]): number;
+export declare function polygonSignature(points: Point2D[]): string;
+export declare function dedupeSequentialPoints(points: Point2D[], tolerance?: number): Point2D[];
+export declare function bboxOf(points: Point2D[]): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export declare function sampleWallPointsForRoomDetection(wall: Pick<WallNode, 'start' | 'end' | 'curveOffset'>, tolerance?: number): Point2D[];
+/** Farthest a wall end may sit off another wall's reference line and still join its body. */
+export declare const TEE_REACH = 0.4;
+/**
+ * How far apart two boundaries' reference lines may be where they still join: the
+ * junction tolerance, or, for walls, as far as their drawn bodies can touch.
+ */
+export declare function junctionReach(a: BoundaryNode, b: BoundaryNode): number;
+/**
+ * True when two boundaries cross away from their ends (sample vertices included).
+ * Room detection and the incremental topology index share this predicate.
+ */
+export declare function boundariesCross(a: BoundaryNode, b: BoundaryNode): boolean;
+export declare function wallEndJoinCandidates(nodes: Readonly<Record<string, AnyNode>>, levelId: string): OpenWallEnd[];
+/** Separator edges preserve intentional openings after wall deletion; only wall ends are reported. */
+export declare function detectOpenWallEnds(nodes: Readonly<Record<string, AnyNode>>, levelId: string): OpenWallEnd[];
+/**
+ * Rooms enclosed by walls and separators. Joints where drawn wall bodies touch (thick
+ * walls, ends inside another wall's body) only ever add or split rooms: wherever they
+ * would lose room area the plain junction rules drew, that structure keeps the plain
+ * result, so no scene loses a room it had.
+ */
+export declare function extractRooms(boundaries: BoundaryNode[], options?: {
+    includeHoles?: boolean;
+}): ExtractedRoom[];
+export type RoomFace = {
+    /** Canonical face id (the extracted room id), stable across callers' face order. */
+    key: string;
+    polygon: Ring;
+    holes: Ring[];
+    boundaryWallIds: WallNode['id'][];
+    boundarySeparatorIds: SeparatorNode['id'][];
+};
+export declare function detectRoomFaces(levelWalls: WallNode[], levelSeparators?: SeparatorNode[]): RoomFace[];
+//# sourceMappingURL=room-graph.d.ts.map

package/dist/lib/room-graph.d.ts.map

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