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

package/dist/services/port-connectivity.js

@@ -0,0 +1,300 @@
+import { nodeRegistry } from '../registry';
+/** Distance (meters) under which two ports count as the same joint. Joints
+ *  formed by placement snapping coincide to sub-millimeter; 5 cm leaves
+ *  generous slack for grid-snapped hand placement without false matches. */
+const COINCIDENT_EPS_M = 0.05;
+/** Below this (meters) a propagated delta is treated as zero — stops the
+ *  walk from chasing sub-millimeter perpendicular residue. */
+const DELTA_EPS_M = 1e-4;
+const PROPAGATION_EPS_M = 1e-9;
+function portsOf(node) {
+    return nodeRegistry.get(node.type)?.ports?.(node);
+}
+/** A node's distribution role from the registry (run / fitting / …). */
+function roleOf(node) {
+    return nodeRegistry.get(node.type)?.distributionRole;
+}
+function distSq(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+/** Two ports mate when they coincide AND don't cross incompatible systems
+ *  (a supply duct and a waste pipe that merely touch must not fuse). */
+function portsMate(a, b, epsSq) {
+    if (distSq(a.position, b.position) > epsSq)
+        return false;
+    if (a.system && b.system && a.system !== b.system)
+        return false;
+    return true;
+}
+/**
+ * Snapshot the joint graph reachable from `movedNode`'s ports, taken at the
+ * start of a move/resize. Call once before the drag; feed the result to
+ * `resolveConnectivityUpdates` on every frame.
+ *
+ * Only `run`-role partners (segments) and `fitting`-role partners are walked —
+ * terminals and equipment usually mount to a surface and shouldn't be yanked
+ * off it when an adjacent fitting nudges. Fittings that declare
+ * `portConnectivityFollow: false` are anchored fixtures (e.g. pipe-trap) and
+ * are skipped, so a connected run stretches against them instead.
+ */
+export function analyzePortConnectivity(movedNode, nodes) {
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    const movedPorts = portsOf(movedNode) ?? [];
+    const startMovedPorts = {};
+    for (const p of movedPorts)
+        startMovedPorts[p.id] = p.position;
+    // Candidate partners: every run + every following fitting in the scene.
+    const candidates = [];
+    for (const other of Object.values(nodes)) {
+        if (!other || other.id === movedNode.id)
+            continue;
+        const role = roleOf(other);
+        if (role !== 'run' && role !== 'fitting')
+            continue;
+        if (role === 'fitting' && nodeRegistry.get(other.type)?.portConnectivityFollow === false) {
+            continue;
+        }
+        const ports = portsOf(other);
+        if (!ports)
+            continue;
+        const startPath = role === 'run'
+            ? other.path?.map((p) => [...p])
+            : undefined;
+        if (role === 'run' && (!startPath || startPath.length < 2))
+            continue;
+        const startPosition = role === 'fitting'
+            ? (() => {
+                const pos = other.position;
+                return pos ? [pos[0], pos[1], pos[2]] : undefined;
+            })()
+            : undefined;
+        if (role === 'fitting' && !startPosition)
+            continue;
+        candidates.push({ id: other.id, role, ports, startPath, startPosition });
+    }
+    // Walk outward from the moved node, collecting every node reachable through
+    // coincident ports. The adjacency records each port's mates so the resolver
+    // can replay the same edges with live deltas.
+    const adjacency = {};
+    const addEdge = (nodeId, portId, mate) => {
+        const byPort = adjacency[nodeId] ?? {};
+        adjacency[nodeId] = byPort;
+        const mates = byPort[portId] ?? [];
+        byPort[portId] = mates;
+        mates.push(mate);
+    };
+    const graph = {};
+    const visited = new Set([movedNode.id]);
+    // Seed: the moved node's own ports.
+    const queue = [{ id: movedNode.id, ports: movedPorts }];
+    while (queue.length > 0) {
+        const { id, ports } = queue.shift();
+        for (const port of ports) {
+            for (const cand of candidates) {
+                if (cand.id === id)
+                    continue;
+                for (const cp of cand.ports) {
+                    if (!portsMate(port, cp, epsSq))
+                        continue;
+                    addEdge(id, port.id, { nodeId: cand.id, portId: cp.id });
+                    addEdge(cand.id, cp.id, { nodeId: id, portId: port.id });
+                    if (!visited.has(cand.id)) {
+                        visited.add(cand.id);
+                        graph[cand.id] = cand;
+                        queue.push({ id: cand.id, ports: cand.ports });
+                    }
+                }
+            }
+        }
+    }
+    const connections = Object.values(graph).map((g) => g.role === 'fitting'
+        ? { kind: 'rigid-node', nodeId: g.id, startPosition: g.startPosition }
+        : { kind: 'run', nodeId: g.id, startPath: g.startPath });
+    return {
+        movedNodeId: movedNode.id,
+        startMovedPorts,
+        graph,
+        adjacency,
+        connections,
+    };
+}
+function add(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function sub(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function lenSq(v) {
+    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+}
+/** Split `delta` into the component along unit `axis` and the remainder. */
+function decompose(delta, axis) {
+    const dot = delta[0] * axis[0] + delta[1] * axis[1] + delta[2] * axis[2];
+    const parallel = [axis[0] * dot, axis[1] * dot, axis[2] * dot];
+    return { parallel, perp: sub(delta, parallel) };
+}
+function scale(v, scalar) {
+    return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
+}
+function average(deltas) {
+    const sum = deltas.reduce((acc, delta) => add(acc, delta), [0, 0, 0]);
+    return scale(sum, 1 / deltas.length);
+}
+function nearlyEqual(a, b) {
+    return lenSq(sub(a, b)) <= DELTA_EPS_M * DELTA_EPS_M;
+}
+function propagationEqual(a, b) {
+    return lenSq(sub(a, b)) <= PROPAGATION_EPS_M * PROPAGATION_EPS_M;
+}
+function effectivePortDeltas(constraints) {
+    return Object.fromEntries(Object.entries(constraints).map(([portId, bySource]) => [
+        portId,
+        average(Object.values(bySource)),
+    ]));
+}
+/** Unit direction of the run's segment adjacent to its `start` / `end` tip. */
+function endpointAxis(path, portId) {
+    const n = path.length;
+    const [a, b] = portId === 'start' ? [path[1], path[0]] : [path[n - 2], path[n - 1]];
+    const dir = sub(b, a);
+    const l2 = lenSq(dir);
+    if (l2 < 1e-12)
+        return [0, 0, 0];
+    const l = Math.sqrt(l2);
+    return [dir[0] / l, dir[1] / l, dir[2] / l];
+}
+function runPathFromSinglePortDelta(startPath, portId, delta) {
+    const nearIdx = portId === 'start' ? 0 : startPath.length - 1;
+    const axis = endpointAxis(startPath, portId);
+    const { parallel, perp } = decompose(delta, axis);
+    const path = startPath.map((p) => add(p, perp));
+    path[nearIdx] = add(path[nearIdx], parallel);
+    return path;
+}
+function runEndpointDeltas(startPath, path) {
+    return {
+        start: sub(path[0], startPath[0]),
+        end: sub(path[path.length - 1], startPath[startPath.length - 1]),
+    };
+}
+function runPathFromPortDeltas(startPath, portDeltas) {
+    const startDelta = portDeltas.start;
+    const endDelta = portDeltas.end;
+    if (startDelta && endDelta) {
+        if (startPath.length === 2) {
+            return [add(startPath[0], startDelta), add(startPath[1], endDelta)];
+        }
+        if (nearlyEqual(startDelta, endDelta)) {
+            return startPath.map((p) => add(p, startDelta));
+        }
+        const startParts = decompose(startDelta, endpointAxis(startPath, 'start'));
+        const endParts = decompose(endDelta, endpointAxis(startPath, 'end'));
+        const commonPerp = average([startParts.perp, endParts.perp]);
+        const path = startPath.map((p) => add(p, commonPerp));
+        path[0] = add(path[0], startParts.parallel);
+        path[path.length - 1] = add(path[path.length - 1], endParts.parallel);
+        return path;
+    }
+    return runPathFromSinglePortDelta(startPath, startDelta ? 'start' : 'end', (startDelta ?? endDelta));
+}
+/**
+ * Given the moved node in its live (in-drag) transform, produce the patches
+ * that keep every connected node attached. `previewNode` is the moved node
+ * with its current drag position/rotation applied so its ports recompute.
+ *
+ * Walks the snapshotted graph, propagating each port delta outward: fittings
+ * translate rigidly, runs stretch along their axis and translate across it
+ * (never skew when driven from one end), and effective port movement carries on
+ * to neighbouring joints. Port-level output guards bound cycles while still
+ * allowing a looped/shared run to accept constraints at both endpoints.
+ */
+export function resolveConnectivityUpdates(connectivity, previewNode) {
+    const { graph, adjacency, startMovedPorts, movedNodeId } = connectivity;
+    if (Object.keys(graph).length === 0)
+        return [];
+    const newPorts = portsOf(previewNode) ?? [];
+    const newMovedPos = {};
+    for (const p of newPorts)
+        newMovedPos[p.id] = p.position;
+    // Each queue item drives a node's port by a delta ("this collar / endpoint
+    // must move by this much").
+    const queue = [];
+    const results = {};
+    const constrainedPorts = {};
+    const propagatedPorts = {};
+    const enqueueMates = (nodeId, portId, delta) => {
+        const byPort = propagatedPorts[nodeId] ?? {};
+        propagatedPorts[nodeId] = byPort;
+        const previous = byPort[portId];
+        if (previous && propagationEqual(previous, delta))
+            return;
+        byPort[portId] = delta;
+        for (const mate of adjacency[nodeId]?.[portId] ?? []) {
+            if (mate.nodeId === movedNodeId)
+                continue;
+            queue.push({
+                nodeId: mate.nodeId,
+                portId: mate.portId,
+                delta,
+                sourceKey: `${nodeId}:${portId}`,
+            });
+        }
+    };
+    const acceptPortDelta = (nodeId, portId, sourceKey, delta) => {
+        const byPort = constrainedPorts[nodeId] ?? {};
+        constrainedPorts[nodeId] = byPort;
+        const bySource = byPort[portId] ?? {};
+        byPort[portId] = bySource;
+        const existing = bySource[sourceKey];
+        if (existing && propagationEqual(existing, delta)) {
+            return false;
+        }
+        bySource[sourceKey] = delta;
+        return true;
+    };
+    // Seed from the moved node's live port deltas.
+    for (const [portId, start] of Object.entries(startMovedPorts)) {
+        const now = newMovedPos[portId];
+        if (!now)
+            continue;
+        const delta = sub(now, start);
+        if (lenSq(delta) <= DELTA_EPS_M * DELTA_EPS_M)
+            continue;
+        enqueueMates(movedNodeId, portId, delta);
+    }
+    while (queue.length > 0) {
+        const { nodeId, portId, delta, sourceKey } = queue.shift();
+        const node = graph[nodeId];
+        if (!node)
+            continue;
+        if (!acceptPortDelta(nodeId, portId, sourceKey, delta))
+            continue;
+        const portDeltas = effectivePortDeltas(constrainedPorts[nodeId]);
+        if (node.role === 'fitting') {
+            const start = node.startPosition;
+            const effectiveDelta = average(Object.values(portDeltas));
+            results[nodeId] = {
+                id: nodeId,
+                data: { position: add(start, effectiveDelta) },
+            };
+            // Rigid: every collar carries the effective body translation onward.
+            for (const p of node.ports) {
+                enqueueMates(nodeId, p.id, effectiveDelta);
+            }
+        }
+        else {
+            const startPath = node.startPath;
+            const path = runPathFromPortDeltas(startPath, portDeltas);
+            results[nodeId] = { id: nodeId, data: { path } };
+            for (const [nextPortId, nextDelta] of Object.entries(runEndpointDeltas(startPath, path))) {
+                if (lenSq(nextDelta) <= DELTA_EPS_M * DELTA_EPS_M)
+                    continue;
+                enqueueMates(nodeId, nextPortId, nextDelta);
+            }
+        }
+    }
+    return Object.values(results);
+}

package/dist/services/riser-diagram.d.ts

@@ -0,0 +1,40 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/** A 3D level-local point (meters) projected to 2D iso screen space.
+ *  Screen Y grows DOWNWARD (SVG convention), so higher elevation → lower
+ *  screen Y. */
+export declare function projectIso(x: number, y: number, z: number): [number, number];
+export type RiserLine = {
+    /** Projected endpoints in iso screen space. */
+    from: [number, number];
+    to: [number, number];
+    system: 'waste' | 'vent';
+    /** Nominal size in inches. */
+    diameter: number;
+    /** True for a (near-)vertical run — drawn solid/bold as a stack. */
+    vertical: boolean;
+    /** Source node, so the editor can link selection. */
+    nodeId: AnyNodeId;
+};
+export type RiserMarker = {
+    point: [number, number];
+    kind: 'trap' | 'vent-termination' | 'fitting';
+    label: string;
+    nodeId: AnyNodeId;
+};
+export type RiserDiagram = {
+    lines: RiserLine[];
+    markers: RiserMarker[];
+    /** Bounding box of all projected geometry, screen space. */
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+};
+/**
+ * Build the riser diagram for the whole scene. Returns null when there's
+ * no DWV geometry to draw.
+ */
+export declare function buildRiserDiagram(nodes: Readonly<Record<AnyNodeId, AnyNode>>): RiserDiagram | null;
+//# sourceMappingURL=riser-diagram.d.ts.map

package/dist/services/riser-diagram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riser-diagram.d.ts","sourceRoot":"","sources":["../../src/services/riser-diagram.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAiBnD;;gBAEgB;AAChB,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5E;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,+CAA+C;IAC/C,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtB,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;IACxB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAA;IACjB,qDAAqD;IACrD,MAAM,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAAA;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,4DAA4D;IAC5D,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CACnE,CAAA;AAcD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,YAAY,GAAG,IAAI,CAuErB"}

package/dist/services/riser-diagram.js

@@ -0,0 +1,110 @@
+/**
+ * Riser diagram (plumbing isometric) — the conventional way DWV systems
+ * are drawn for permit: the drain/vent tree projected to a 30° iso so
+ * vertical stacks read as vertical and horizontal runs lean off at 30°,
+ * annotated with size + slope and vent terminations.
+ *
+ * This is a pure projector: it turns the scene's DWV nodes into 2D
+ * drawables (level-independent, no rendering). The editor draws the
+ * result as SVG. Air/refrigerant nodes are ignored — riser diagrams are
+ * a plumbing convention.
+ */
+const COS30 = Math.cos(Math.PI / 6);
+const SIN30 = Math.sin(Math.PI / 6);
+/** A 3D level-local point (meters) projected to 2D iso screen space.
+ *  Screen Y grows DOWNWARD (SVG convention), so higher elevation → lower
+ *  screen Y. */
+export function projectIso(x, y, z) {
+    const sx = (x - z) * COS30;
+    const sy = (x + z) * SIN30 - y;
+    return [sx, sy];
+}
+/** Elevation gain per horizontal meter under which a leg is "vertical". */
+const VERTICAL_EPS = 4; // dy/dxz ratio: steeper than this reads as a stack
+function legIsVertical(a, b) {
+    const horizontal = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    const vertical = Math.abs(b[1] - a[1]);
+    if (horizontal < 1e-4)
+        return true;
+    return vertical / horizontal > VERTICAL_EPS;
+}
+/**
+ * Build the riser diagram for the whole scene. Returns null when there's
+ * no DWV geometry to draw.
+ */
+export function buildRiserDiagram(nodes) {
+    const lines = [];
+    const markers = [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const grow = (p) => {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[1] < minY)
+            minY = p[1];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[1] > maxY)
+            maxY = p[1];
+    };
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        if (node.type === 'pipe-segment') {
+            const path = node.path;
+            for (let i = 0; i < path.length - 1; i++) {
+                const a = path[i];
+                const b = path[i + 1];
+                const from = projectIso(a[0], a[1], a[2]);
+                const to = projectIso(b[0], b[1], b[2]);
+                grow(from);
+                grow(to);
+                lines.push({
+                    from,
+                    to,
+                    system: node.system,
+                    diameter: node.diameter,
+                    vertical: legIsVertical(a, b),
+                    nodeId: node.id,
+                });
+            }
+            // Vent runs that end above everything are vent terminations
+            // (through-roof). Tag the highest endpoint of a vent run.
+            if (node.system === 'vent') {
+                const top = path.reduce((hi, p) => (p[1] > hi[1] ? p : hi), path[0]);
+                const pt = projectIso(top[0], top[1], top[2]);
+                markers.push({
+                    point: pt,
+                    kind: 'vent-termination',
+                    label: `${node.diameter}" VTR`,
+                    nodeId: node.id,
+                });
+            }
+        }
+        else if (node.type === 'pipe-trap') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'trap',
+                label: `${node.diameter}" P-trap`,
+                nodeId: node.id,
+            });
+        }
+        else if (node.type === 'pipe-fitting') {
+            const pt = projectIso(node.position[0], node.position[1], node.position[2]);
+            grow(pt);
+            markers.push({
+                point: pt,
+                kind: 'fitting',
+                label: node.fittingType,
+                nodeId: node.id,
+            });
+        }
+    }
+    if (lines.length === 0 && markers.length === 0)
+        return null;
+    return { lines, markers, bounds: { minX, minY, maxX, maxY } };
+}

package/dist/services/snap.d.ts

@@ -12,7 +12,7 @@ export type Vec2 = readonly [number, number];
 export type Vec3 = readonly [number, number, number];
 /** Default planar grid spacing in meters. Matches the editor's wall tool. */
 export declare const DEFAULT_GRID_STEP = 0.25;
-/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+/** Default angle-snap step — π/12 = 15°. */
 export declare const DEFAULT_ANGLE_STEP: number;
 /** Snaps a single scalar to the nearest multiple of `step`. */
 export declare function snapScalar(value: number, step?: number): number;
@@ -45,6 +45,14 @@ export declare function snapWorldXZToBuildingLocal(worldX: number, worldZ: numbe
  * — keeps endpoints landing on grid intersections.
  */
 export declare function snapPointToAngle(from: Vec2, cursor: Vec2, angleStep?: number, gridStep?: number): Vec2;
+/**
+ * Snaps a cursor point onto the nearest angle ray from `from` (multiples of
+ * `angleStep`), projecting the cursor onto that ray, then snaps the distance
+ * ALONG the ray to `distanceStep`. Unlike `snapPointToAngle` with a
+ * `gridStep`, the result stays exactly on the snapped ray — grid-snapping
+ * after the angle projection pulls points off non-axis rays.
+ */
+export declare function snapPointAlongAngleRay(from: Vec2, cursor: Vec2, angleStep?: number, distanceStep?: number): Vec2;
 /**
  * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
  * radians). Returns the original angle if no entry is within `toleranceRad`.

package/dist/services/snap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../../src/services/snap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC5C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,QAAe,CAAA;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA0B,GAAG,MAAM,CAGlF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAEnF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE,MAA0B,GAC/B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2BtD;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,YAAY,GAAE,MAAqB,GAClC,MAAM,CAcR;AAID;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACrD,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACjF,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACtF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}
+{"version":3,"file":"snap.d.ts","sourceRoot":"","sources":["../../src/services/snap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC5C,MAAM,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpD,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB,QAAe,CAAA;AAI9C,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAA0B,GAAG,MAAM,CAGlF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAEnF;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,GAAE,MAA0B,GAAG,IAAI,CAElF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE,MAA0B,GAC/B;IAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA2BtD;AAID;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,IAAI,EACZ,SAAS,GAAE,MAA2B,EACtC,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAYN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,YAAY,GAAE,MAAqB,GAClC,MAAM,CAcR;AAID;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACrD,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;QACjF,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;KACtF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,YAU1B,CAAA"}

package/dist/services/snap.js

@@ -10,7 +10,7 @@
  */
 /** Default planar grid spacing in meters. Matches the editor's wall tool. */
 export const DEFAULT_GRID_STEP = 0.25;
-/** Default angle-snap step — π/12 = 15°. Wall tools also use π/4 (45°). */
+/** Default angle-snap step — π/12 = 15°. */
 export const DEFAULT_ANGLE_STEP = Math.PI / 12;
 // ─── Grid snap ────────────────────────────────────────────────────────
 /** Snaps a single scalar to the nearest multiple of `step`. */
@@ -88,6 +88,26 @@ export function snapPointToAngle(from, cursor, angleStep = DEFAULT_ANGLE_STEP, g
     ];
     return gridStep == null ? projected : snapPointToGrid(projected, gridStep);
 }
+/**
+ * Snaps a cursor point onto the nearest angle ray from `from` (multiples of
+ * `angleStep`), projecting the cursor onto that ray, then snaps the distance
+ * ALONG the ray to `distanceStep`. Unlike `snapPointToAngle` with a
+ * `gridStep`, the result stays exactly on the snapped ray — grid-snapping
+ * after the angle projection pulls points off non-axis rays.
+ */
+export function snapPointAlongAngleRay(from, cursor, angleStep = DEFAULT_ANGLE_STEP, distanceStep) {
+    const dx = cursor[0] - from[0];
+    const dz = cursor[1] - from[1];
+    if (dx === 0 && dz === 0)
+        return [from[0], from[1]];
+    const angle = Math.atan2(dz, dx);
+    const snappedAngle = angleStep > 0 ? Math.round(angle / angleStep) * angleStep : angle;
+    const dirX = Math.cos(snappedAngle);
+    const dirZ = Math.sin(snappedAngle);
+    const projected = dx * dirX + dz * dirZ;
+    const distance = distanceStep != null && distanceStep > 0 ? snapScalar(projected, distanceStep) : projected;
+    return [from[0] + dirX * distance, from[1] + dirZ * distance];
+}
 /**
  * Snaps an angle (in radians) to the nearest entry in `snapAngles` (also in
  * radians). Returns the original angle if no entry is within `toleranceRad`.

package/dist/services/storey.d.ts

@@ -0,0 +1,103 @@
+import type { LevelNode, WallNode } from '../schema';
+import type { AnyNode, AnyNodeId } from '../schema/types';
+/**
+ * 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 declare 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 declare function getStoredLevelHeight(level: Pick<LevelNode, 'height'>): number;
+export type LevelElevation = {
+    /** World Y of the level's floor: prefix sum of the storey heights below it. */
+    baseY: number;
+    /** Stored storey height of this level (fallback applied). */
+    height: number;
+    buildingId: string | null;
+    ordinal: number;
+};
+/**
+ * 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 declare function getLevelElevations(nodes: Record<AnyNodeId, AnyNode>): Map<string, LevelElevation>;
+/**
+ * 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 declare function findLevelAboveId(levelId: string, elevations: Map<string, LevelElevation>): string | null;
+/**
+ * The level directly above `levelId` — see {@link findLevelAboveId}.
+ * `null` when topmost or unresolvable. Pure.
+ */
+export declare function getLevelAbove(levelId: string, nodes: Record<AnyNodeId, AnyNode>): LevelNode | 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 declare function findLevelBelowId(levelId: string, elevations: Map<string, LevelElevation>): string | null;
+/**
+ * The level directly below `levelId` — see {@link findLevelBelowId}.
+ * `null` when lowest or unresolvable. Pure.
+ */
+export declare function getLevelBelow(levelId: string, nodes: Record<AnyNodeId, AnyNode>): LevelNode | null;
+/**
+ * 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 declare function getCoveringSlabUndersideAt(levelId: string, nodes: Record<AnyNodeId, AnyNode>, x: number, z: number): number | null;
+/**
+ * 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 declare function getWallPlaneTop(wall: Pick<WallNode, 'start' | 'end'> & Partial<Pick<WallNode, 'thickness' | 'curveOffset'>>, levelId: string, nodes: Record<AnyNodeId, AnyNode>): number;
+/**
+ * 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 declare function getCeilingClampBound(levelId: string, nodes: Record<AnyNodeId, AnyNode>, polygon: ReadonlyArray<[number, number]>): number;
+//# sourceMappingURL=storey.d.ts.map

package/dist/services/storey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storey.d.ts","sourceRoot":"","sources":["../../src/services/storey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,SAAS,EAAY,QAAQ,EAAE,MAAM,WAAW,CAAA;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAQzD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,MAAM,CAE7E;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,+EAA+E;IAC/E,KAAK,EAAE,MAAM,CAAA;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAgCjG;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACtC,MAAM,GAAG,IAAI,CAef;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAKlB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACtC,MAAM,GAAG,IAAI,CAef;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAKlB;AAuFD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,GAAG,IAAI,CAIf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,aAAa,CAAC,CAAC,EAC5F,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,MAAM,CAYR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACvC,MAAM,CAuBR"}