@pascal-app/core 0.9.1 → 1.0.0-beta.1

package/dist/services/storey.js

@@ -0,0 +1,296 @@
+import { pointInPolygon, pointOnPolygonBoundary, wallOverlapsSlabFootprint, } from '../systems/slab/slab-support';
+import { DEFAULT_LEVEL_HEIGHT } from './level-height';
+/**
+ * Gap kept between a ceiling's stored height and its clamp bound (storey
+ * plane or covering-slab underside), so the ceiling surface never
+ * coincides with the solid above it.
+ */
+export const CEILING_CLAMP_MARGIN = 0.01;
+/**
+ * Stored storey height in meters (floor-to-floor). Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} for unmigrated legacy levels whose `height`
+ * field is absent.
+ */
+export function getStoredLevelHeight(level) {
+    return level.height ?? DEFAULT_LEVEL_HEIGHT;
+}
+/**
+ * Resolves the owning building: explicit `parentId` pointing at a building
+ * wins; legacy levels that only appear in a building's `children` array
+ * resolve through that membership.
+ */
+function resolveLevelBuildingId(levelId, parentId, buildings) {
+    const directParent = parentId ? buildings.find((building) => building.id === parentId) : undefined;
+    if (directParent)
+        return directParent.id;
+    return buildings.find((building) => building.children.includes(levelId))?.id ?? null;
+}
+/**
+ * Per-building stacked elevations from stored storey heights: levels are
+ * sorted by ordinal ascending within each building, the lowest level's floor
+ * sits at 0, and each next floor sits on top of the previous storey height.
+ * Levels with no resolvable building share one legacy stack from 0.
+ *
+ * Pure — operates on the serialized nodes record only.
+ */
+export function getLevelElevations(nodes) {
+    const buildings = Object.values(nodes).filter((node) => node?.type === 'building');
+    const entries = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'level')
+            continue;
+        const level = node;
+        entries.push({
+            levelId: level.id,
+            baseY: 0,
+            height: getStoredLevelHeight(level),
+            buildingId: resolveLevelBuildingId(level.id, level.parentId, buildings),
+            ordinal: level.level,
+        });
+    }
+    const elevations = new Map();
+    const cumulativeYByBuilding = new Map();
+    for (const entry of entries.sort((a, b) => a.ordinal - b.ordinal)) {
+        const baseY = cumulativeYByBuilding.get(entry.buildingId) ?? 0;
+        elevations.set(entry.levelId, {
+            baseY,
+            height: entry.height,
+            buildingId: entry.buildingId,
+            ordinal: entry.ordinal,
+        });
+        cumulativeYByBuilding.set(entry.buildingId, baseY + entry.height);
+    }
+    return elevations;
+}
+/**
+ * The id of the level directly above `levelId` in its own stack (same
+ * resolved building, or the shared legacy stack for building-less levels):
+ * the level with the lowest ordinal strictly greater than the queried
+ * level's. `null` when the level is topmost or unresolvable.
+ */
+export function findLevelAboveId(levelId, elevations) {
+    const entry = elevations.get(levelId);
+    if (!entry)
+        return null;
+    let aboveId = null;
+    let aboveOrdinal = Number.POSITIVE_INFINITY;
+    for (const [candidateId, candidate] of elevations) {
+        if (candidateId === levelId)
+            continue;
+        if (candidate.buildingId !== entry.buildingId)
+            continue;
+        if (candidate.ordinal > entry.ordinal && candidate.ordinal < aboveOrdinal) {
+            aboveOrdinal = candidate.ordinal;
+            aboveId = candidateId;
+        }
+    }
+    return aboveId;
+}
+/**
+ * The level directly above `levelId` — see {@link findLevelAboveId}.
+ * `null` when topmost or unresolvable. Pure.
+ */
+export function getLevelAbove(levelId, nodes) {
+    const aboveId = findLevelAboveId(levelId, getLevelElevations(nodes));
+    if (!aboveId)
+        return null;
+    const above = nodes[aboveId];
+    return above?.type === 'level' ? above : null;
+}
+/**
+ * The id of the level directly below `levelId` in its own stack — mirror of
+ * {@link findLevelAboveId}: the level with the highest ordinal strictly less
+ * than the queried level's. `null` when the level is lowest or unresolvable.
+ */
+export function findLevelBelowId(levelId, elevations) {
+    const entry = elevations.get(levelId);
+    if (!entry)
+        return null;
+    let belowId = null;
+    let belowOrdinal = Number.NEGATIVE_INFINITY;
+    for (const [candidateId, candidate] of elevations) {
+        if (candidateId === levelId)
+            continue;
+        if (candidate.buildingId !== entry.buildingId)
+            continue;
+        if (candidate.ordinal < entry.ordinal && candidate.ordinal > belowOrdinal) {
+            belowOrdinal = candidate.ordinal;
+            belowId = candidateId;
+        }
+    }
+    return belowId;
+}
+/**
+ * The level directly below `levelId` — see {@link findLevelBelowId}.
+ * `null` when lowest or unresolvable. Pure.
+ */
+export function getLevelBelow(levelId, nodes) {
+    const belowId = findLevelBelowId(levelId, getLevelElevations(nodes));
+    if (!belowId)
+        return null;
+    const below = nodes[belowId];
+    return below?.type === 'level' ? below : null;
+}
+/**
+ * Storey height of the queried level plus the level-above's covering
+ * (non-recessed) slabs. `null` when `levelId` doesn't resolve to a level.
+ * A missing level above yields an empty slab list, not `null` — the
+ * storey height is still meaningful for the clamp bound.
+ */
+function resolveCoveringSlabContext(levelId, nodes) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const above = getLevelAbove(levelId, nodes);
+    const slabs = [];
+    for (const childId of above?.children ?? []) {
+        const child = nodes[childId];
+        if (child?.type !== 'slab')
+            continue;
+        const slab = child;
+        // Recessed slabs (pools) are open shells, not covering solids.
+        if (slab.recessed === true)
+            continue;
+        if (slab.polygon.length < 3)
+            continue;
+        slabs.push(slab);
+    }
+    return { storeyHeight: getStoredLevelHeight(level), slabs };
+}
+/**
+ * Underside of `slab`'s solid in the QUERIED level's local Y. The solid
+ * occupies `[elevation - thickness, elevation]` in ITS level's local Y,
+ * which sits `storeyHeight` above the queried level's floor.
+ */
+function coveringUndersideY(storeyHeight, slab) {
+    return storeyHeight + ((slab.elevation ?? 0.05) - (slab.thickness ?? 0.05));
+}
+/**
+ * Whether `slab`'s stored footprint (polygon minus holes) covers `[x, z]`.
+ * Ray-cast pointInPolygon flips arbitrarily for points exactly ON the
+ * boundary (min-side edges read inside, max-side edges outside), so
+ * boundary contact counts as covered explicitly — the same convention as
+ * the slab-support interval classification. A point on a hole's rim keeps
+ * coverage (mirrors the support election's hole handling).
+ *
+ * Raw stored polygon + holes on purpose (mirrors getCeilingAt): the
+ * clamp bound doesn't need the rendered footprint's junction trims,
+ * and staying off the render path keeps this query cheap and pure.
+ */
+function slabCoversPoint(slab, x, z) {
+    if (!pointInPolygon(x, z, slab.polygon) && !pointOnPolygonBoundary(x, z, slab.polygon)) {
+        return false;
+    }
+    for (const hole of slab.holes ?? []) {
+        if (hole.length < 3)
+            continue;
+        if (pointInPolygon(x, z, hole) && !pointOnPolygonBoundary(x, z, hole))
+            return false;
+    }
+    return true;
+}
+/**
+ * Lowest underside among `slabs` covering `[x, z]`, in the queried
+ * level's local Y, or `null` when none covers the point.
+ */
+function lowestCoveringUndersideAt(context, x, z) {
+    let lowest = null;
+    for (const slab of context.slabs) {
+        if (!slabCoversPoint(slab, x, z))
+            continue;
+        const underside = coveringUndersideY(context.storeyHeight, slab);
+        if (lowest === null || underside < lowest)
+            lowest = underside;
+    }
+    return lowest;
+}
+/**
+ * Underside of the LOWEST slab from the level above that covers
+ * level-local point `[x, z]`, expressed in the queried level's local Y:
+ * `storeyHeight + (slab.elevation - slab.thickness)`. `recessed` slabs
+ * (pools) never cover. `null` when no covering slab (or no level above).
+ *
+ * Coordinate spaces: levels stack in Y only (`LevelNode` carries no XZ
+ * transform and the viewer's LevelSystem writes only `position.y`), so a
+ * level-local `[x, z]` is valid in every level of the stack unchanged.
+ */
+export function getCoveringSlabUndersideAt(levelId, nodes, x, z) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return null;
+    return lowestCoveringUndersideAt(context, x, z);
+}
+/**
+ * Top plane for a plane-bound wall on `levelId`, in level-local Y:
+ * `min(stored storey height, lowest covering-slab underside over the wall's
+ * span)` — a thick or flush slab on the level above SHORTENS the walls below
+ * instead of colliding with them (Revit-style automatic attach).
+ *
+ * Coverage: the wall's thickness band (centerline + face lines, arc-aware)
+ * is clipped against each covering slab's stored polygon minus holes via
+ * {@link wallOverlapsSlabFootprint} — the same overlap machinery as the
+ * support election. Point sampling is deliberately avoided: auto-slab
+ * polygons derive from wall CENTERLINES, so perimeter walls sit exactly ON
+ * the polygon boundary, where ray-cast point-in-polygon flips with the
+ * edge's orientation (one wall clamped, its neighbor didn't). Boundary
+ * contact counts as covered on every side of the slab.
+ *
+ * This is THE plane for a plane-bound wall (`height` absent). Explicit-height
+ * walls ignore the value (`resolveWallTop` returns their stored height), so
+ * passing it wherever a raw storey height feeds `resolveWallTop` /
+ * `resolveWallEffectiveHeight` is always safe. Falls back to
+ * {@link DEFAULT_LEVEL_HEIGHT} when `levelId` doesn't resolve to a level.
+ */
+export function getWallPlaneTop(wall, levelId, nodes) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return DEFAULT_LEVEL_HEIGHT;
+    let plane = context.storeyHeight;
+    for (const slab of context.slabs) {
+        const underside = coveringUndersideY(context.storeyHeight, slab);
+        if (underside >= plane)
+            continue;
+        if (!wallOverlapsSlabFootprint(wall, slab.polygon, slab.holes))
+            continue;
+        plane = underside;
+    }
+    return plane;
+}
+/**
+ * Upper bound for a ceiling's stored height over `polygon` on `levelId`:
+ * `min(storey plane, lowest covering-slab underside) - CEILING_CLAMP_MARGIN`.
+ * The covering underside is sampled at every polygon vertex plus the
+ * centroid — cheap, and a slab overlapping a convex-ish ceiling almost
+ * always covers one of those points; exact polygon-vs-polygon overlap is
+ * not worth its cost for a clamp bound. Ceiling outlines share footprint
+ * edges with the slabs above them the same way walls do, so vertices
+ * sitting exactly on a slab's boundary count as covered on every side
+ * (see `slabCoversPoint`) instead of flipping with the edge orientation.
+ *
+ * Returns `Infinity` when `levelId` doesn't resolve, so callers clamp
+ * against nothing rather than a garbage plane.
+ */
+export function getCeilingClampBound(levelId, nodes, polygon) {
+    const context = resolveCoveringSlabContext(levelId, nodes);
+    if (!context)
+        return Number.POSITIVE_INFINITY;
+    let bound = context.storeyHeight;
+    if (polygon.length > 0) {
+        let cx = 0;
+        let cz = 0;
+        for (const [x, z] of polygon) {
+            cx += x;
+            cz += z;
+        }
+        const samples = [
+            ...polygon,
+            [cx / polygon.length, cz / polygon.length],
+        ];
+        for (const [x, z] of samples) {
+            const underside = lowestCoveringUndersideAt(context, x, z);
+            if (underside !== null && underside < bound)
+                bound = underside;
+        }
+    }
+    return bound - CEILING_CLAMP_MARGIN;
+}

package/dist/services/system-graph.d.ts

@@ -0,0 +1,30 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+export type SystemSummary = {
+    /** Every node in this connected component. */
+    nodeIds: AnyNodeId[];
+    /** Distribution loops present, e.g. ['supply'], ['supply','return']. */
+    systems: string[];
+    /** Duct / lineset run statistics. */
+    runCount: number;
+    runLengthM: number;
+    fittingCount: number;
+    terminalCount: number;
+    equipmentCount: number;
+    /** False = orphaned subtree: air goes nowhere (no furnace / air
+     *  handler / condenser anywhere in the component). */
+    connectedToEquipment: boolean;
+};
+/**
+ * Group every port-bearing node into connected components via coinciding
+ * ports. Nodes with ports but no joints form singleton components; nodes
+ * without `def.ports` don't participate at all.
+ */
+export declare function buildPortComponents(nodes: Readonly<Record<AnyNodeId, AnyNode>>): AnyNodeId[][];
+/**
+ * Summary of the system the given node belongs to, or null when the node
+ * has no ports (not a distribution kind). A node with ports but no
+ * joints yet still gets a (singleton) summary — `connectedToEquipment:
+ * false` is the interesting signal there.
+ */
+export declare function summarizeSystemFor(nodeId: AnyNodeId, nodes: Readonly<Record<AnyNodeId, AnyNode>>): SystemSummary | null;
+//# sourceMappingURL=system-graph.d.ts.map

package/dist/services/system-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-graph.d.ts","sourceRoot":"","sources":["../../src/services/system-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAoBnD,MAAM,MAAM,aAAa,GAAG;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,wEAAwE;IACxE,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB;0DACsD;IACtD,oBAAoB,EAAE,OAAO,CAAA;CAC9B,CAAA;AA2DD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,EAAE,CA4B9F;AAkDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,aAAa,GAAG,IAAI,CAStB"}

package/dist/services/system-graph.js

@@ -0,0 +1,164 @@
+import { nodeRegistry } from '../registry';
+/**
+ * The "System" primitive: connected components over the port graph.
+ *
+ * Two nodes are joined when a port of one coincides in space with a port
+ * of the other — the same mated-joint relationship `port-connectivity`
+ * uses for drag propagation, read here at whole-scene scope. A component
+ * is one distribution system: a furnace, its trunk, the tees, branches,
+ * and registers hanging off it.
+ *
+ * Pure logic (def.ports + arithmetic), no rendering — lives in core so
+ * the editor (badges, schedules) and analyses (sizing, code checks) can
+ * share it.
+ */
+/** Distance (meters) under which two ports count as the same joint —
+ *  matches port-connectivity's tolerance for hand-placed joints. */
+const COINCIDENT_EPS_M = 0.05;
+function collectPorts(nodes) {
+    const result = [];
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        const ports = nodeRegistry.get(node.type)?.ports?.(node);
+        if (!ports)
+            continue;
+        for (const port of ports) {
+            result.push({
+                nodeId: node.id,
+                x: port.position[0],
+                y: port.position[1],
+                z: port.position[2],
+                system: port.system,
+            });
+        }
+    }
+    return result;
+}
+/** Union-find over node ids. */
+class Components {
+    parent = new Map();
+    find(id) {
+        let root = this.parent.get(id) ?? id;
+        if (root !== id) {
+            root = this.find(root);
+            this.parent.set(id, root);
+        }
+        return root;
+    }
+    union(a, b) {
+        const ra = this.find(a);
+        const rb = this.find(b);
+        if (ra !== rb)
+            this.parent.set(rb, ra);
+    }
+}
+function pathLength(path) {
+    let total = 0;
+    for (let i = 0; i < path.length - 1; i++) {
+        const a = path[i];
+        const b = path[i + 1];
+        total += Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    }
+    return total;
+}
+/**
+ * Group every port-bearing node into connected components via coinciding
+ * ports. Nodes with ports but no joints form singleton components; nodes
+ * without `def.ports` don't participate at all.
+ */
+export function buildPortComponents(nodes) {
+    const ports = collectPorts(nodes);
+    const components = new Components();
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    for (let i = 0; i < ports.length; i++) {
+        const a = ports[i];
+        for (let j = i + 1; j < ports.length; j++) {
+            const b = ports[j];
+            if (a.nodeId === b.nodeId)
+                continue;
+            const dx = a.x - b.x;
+            const dy = a.y - b.y;
+            const dz = a.z - b.z;
+            if (dx * dx + dy * dy + dz * dz <= epsSq)
+                components.union(a.nodeId, b.nodeId);
+        }
+    }
+    const grouped = new Map();
+    const seen = new Set();
+    for (const port of ports) {
+        if (seen.has(port.nodeId))
+            continue;
+        seen.add(port.nodeId);
+        const root = components.find(port.nodeId);
+        const group = grouped.get(root);
+        if (group)
+            group.push(port.nodeId);
+        else
+            grouped.set(root, [port.nodeId]);
+    }
+    return [...grouped.values()];
+}
+function summarize(nodeIds, nodes) {
+    const systems = new Set();
+    let runCount = 0;
+    let runLengthM = 0;
+    let fittingCount = 0;
+    let terminalCount = 0;
+    let equipmentCount = 0;
+    for (const id of nodeIds) {
+        const node = nodes[id];
+        if (!node)
+            continue;
+        const role = nodeRegistry.get(node.type)?.distributionRole;
+        const fields = node;
+        if (role === 'run') {
+            runCount += 1;
+            if (fields.path)
+                runLengthM += pathLength(fields.path);
+            // Linesets carry refrigerant; duct / pipe runs name their own loop.
+            systems.add(fields.system ?? 'refrigerant');
+        }
+        else if (role === 'fitting') {
+            fittingCount += 1;
+            if (fields.system)
+                systems.add(fields.system);
+        }
+        else if (role === 'terminal') {
+            terminalCount += 1;
+            systems.add(fields.terminalType === 'return-grille' ? 'return' : 'supply');
+        }
+        else if (role === 'equipment') {
+            equipmentCount += 1;
+        }
+    }
+    return {
+        nodeIds,
+        systems: [...systems].sort(),
+        runCount,
+        runLengthM,
+        fittingCount,
+        terminalCount,
+        equipmentCount,
+        connectedToEquipment: equipmentCount > 0,
+    };
+}
+/**
+ * Summary of the system the given node belongs to, or null when the node
+ * has no ports (not a distribution kind). A node with ports but no
+ * joints yet still gets a (singleton) summary — `connectedToEquipment:
+ * false` is the interesting signal there.
+ */
+export function summarizeSystemFor(nodeId, nodes) {
+    const node = nodes[nodeId];
+    if (!node)
+        return null;
+    const ports = nodeRegistry.get(node.type)?.ports?.(node);
+    if (!ports || ports.length === 0)
+        return null;
+    for (const component of buildPortComponents(nodes)) {
+        if (component.includes(nodeId))
+            return summarize(component, nodes);
+    }
+    return summarize([nodeId], nodes);
+}

package/dist/services/validate-dwv.d.ts

@@ -0,0 +1,32 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/**
+ * IPC validators for the DWV (drain-waste-vent) system — the "CodeRule"
+ * primitive from the domain brief. The slope, minimum-size, and
+ * trap-arm rules are all geometric and read straight off the node
+ * fields, so they live here in core (pure logic) where the editor can
+ * surface them and analyses can reuse them.
+ *
+ * Scope is residential IPC, simplified:
+ *   - 704.1 drainage slope by pipe size.
+ *   - 909 trap-arm maximum developed length by trap size.
+ *
+ * These are intentionally conservative approximations, not a certified
+ * plan-check — enough to flag the mistakes a drawing tool invites.
+ */
+/** Drainage findings, worst-first per consumer's sort. */
+export type DwvSeverity = 'error' | 'warning';
+export type DwvFinding = {
+    severity: DwvSeverity;
+    /** Stable rule id, e.g. 'slope-too-flat'. */
+    code: string;
+    /** Human-readable, already-formatted message. */
+    message: string;
+    /** Nodes the finding implicates (usually one). */
+    nodeIds: AnyNodeId[];
+};
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export declare function validateDwv(nodes: Readonly<Record<AnyNodeId, AnyNode>>): DwvFinding[];
+//# sourceMappingURL=validate-dwv.d.ts.map

package/dist/services/validate-dwv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-dwv.d.ts","sourceRoot":"","sources":["../../src/services/validate-dwv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAGnD;;;;;;;;;;;;;GAaG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,WAAW,CAAA;IACrB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,OAAO,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAuDD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,UAAU,EAAE,CAwErF"}

package/dist/services/validate-dwv.js

@@ -0,0 +1,118 @@
+import { buildPortComponents } from './system-graph';
+/** IPC 704.1 minimum drainage slope (rise/run, dimensionless) by
+ *  nominal pipe size: ¼"/ft (1:48) under 3", ⅛"/ft (1:96) for 3–6",
+ *  1/16"/ft (1:192) at 8"+. */
+function minSlopeFor(diameterIn) {
+    if (diameterIn < 3)
+        return 1 / 48;
+    if (diameterIn < 8)
+        return 1 / 96;
+    return 1 / 192;
+}
+/** IPC Table 909.1 maximum trap-arm developed length (meters) by trap
+ *  size: 30" @ 1¼", 42" @ 1½", 60" @ 2", 72" @ 3", 120" @ 4". */
+const TRAP_ARM_MAX_M = [
+    [1.25, 30 * 0.0254],
+    [1.5, 42 * 0.0254],
+    [2, 60 * 0.0254],
+    [3, 72 * 0.0254],
+    [4, 120 * 0.0254],
+];
+function trapArmMaxFor(diameterIn) {
+    let max = Infinity;
+    for (const [size, lengthM] of TRAP_ARM_MAX_M) {
+        if (diameterIn <= size)
+            return lengthM;
+        max = lengthM;
+    }
+    return max;
+}
+/** Slopes shallower than this fraction of the minimum are flagged
+ *  "too flat" — a small tolerance keeps round-off off the list. */
+const SLOPE_TOLERANCE = 0.9;
+/** Horizontal legs shorter than this (meters) are treated as vertical
+ *  stacks and skipped from the slope check. */
+const VERTICAL_LEG_EPS_M = 0.02;
+function legSlope(a, b) {
+    const horizontalM = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    if (horizontalM < VERTICAL_LEG_EPS_M)
+        return { horizontalM, slope: Infinity };
+    return { horizontalM, slope: Math.abs(a[1] - b[1]) / horizontalM };
+}
+function inchLabel(value) {
+    return `${value}"`;
+}
+/** Per-foot slope as a readable fraction, e.g. 0.0208 → '¼"/ft'. */
+function slopePerFootLabel(slope) {
+    const inchesPerFoot = slope * 12;
+    return `${inchesPerFoot.toFixed(2)}"/ft`;
+}
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export function validateDwv(nodes) {
+    const findings = [];
+    // ── Per-segment slope (waste only) ──────────────────────────────
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'pipe-segment' || node.system !== 'waste')
+            continue;
+        const path = node.path;
+        const minSlope = minSlopeFor(node.diameter);
+        const maxSlope = node.diameter / 12; // 1 pipe-diameter per foot → siphoning
+        let flaggedFlat = false;
+        let flaggedSteep = false;
+        for (let i = 0; i < path.length - 1; i++) {
+            const { slope } = legSlope(path[i], path[i + 1]);
+            if (slope === Infinity)
+                continue; // vertical stack leg
+            if (!flaggedFlat && slope < minSlope * SLOPE_TOLERANCE) {
+                findings.push({
+                    severity: 'error',
+                    code: 'slope-too-flat',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — IPC 704.1 requires at least ${slopePerFootLabel(minSlope)}.`,
+                    nodeIds: [node.id],
+                });
+                flaggedFlat = true;
+            }
+            if (!flaggedSteep && slope > maxSlope) {
+                findings.push({
+                    severity: 'warning',
+                    code: 'slope-too-steep',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — over one pipe-diameter per foot risks siphoning the traps.`,
+                    nodeIds: [node.id],
+                });
+                flaggedSteep = true;
+            }
+        }
+    }
+    // ── Component-scoped trap rules ──────────────────────────────────
+    for (const component of buildPortComponents(nodes)) {
+        const traps = [];
+        for (const id of component) {
+            const node = nodes[id];
+            if (!node)
+                continue;
+            if (node.type === 'pipe-trap') {
+                traps.push(node);
+            }
+        }
+        // Trap-arm developed length: trap outlet → its vent, capped by size.
+        // Independent of waste segments — a trap on its own can already be
+        // over-armed.
+        for (const trap of traps) {
+            const t = trap;
+            const armLengthM = t.armLengthM ?? 0;
+            const maxArm = trapArmMaxFor(t.diameter);
+            if (armLengthM > maxArm + 1e-6) {
+                findings.push({
+                    severity: 'error',
+                    code: 'trap-arm-too-long',
+                    message: `${inchLabel(t.diameter)} trap arm runs ${(armLengthM / 0.0254).toFixed(0)}" to its vent — IPC 909.1 caps it at ${(maxArm / 0.0254).toFixed(0)}".`,
+                    nodeIds: [t.id],
+                });
+            }
+        }
+    }
+    return findings;
+}

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAKf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AAqrB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAoIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA2ErD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EASf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AA0vB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAyIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoFrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SA8JjB,CAAA"}