@pascal-app/core 1.0.7 → 1.1.1

package/dist/lib/floorplan/marks.d.ts

@@ -0,0 +1,71 @@
+import type { AnyNode, AnyNodeId, DoorNode, WindowNode } from '../../schema/index.js';
+/**
+ * Deterministic door / window marks per level — WS3.
+ *
+ * `packages/core/src/schema/nodes/door.ts:75-79` promises "the deterministic
+ * level fallback (101, 102, ...)"; this is the implementation.
+ *
+ * Numbering
+ * ---------
+ *   base   = (level.level + 1) * 100          — level 0 → 100, level 1 → 200
+ *   doors  = `D${base + n}`   → D101, D102 …
+ *   windows= `W${base + n}`   → W101, W102 …
+ *
+ * Order
+ * -----
+ * Openings are visited **clockwise** around the level, starting from the
+ * north-west-most exterior wall, exterior walls first and interior walls
+ * after. Clockwise is the ascending-angle sweep of the wall midpoint about
+ * the level centroid, anchored on the north-west diagonal (plan axes are
+ * x east, z south — z grows down the screen — so a screen-clockwise sweep
+ * is increasing atan2(z, x)). Openings on the same wall are ordered along
+ * the wall direction.
+ *
+ * Stability
+ * ---------
+ * An explicit `mark` on the node always wins and is never reassigned.
+ * `resolveMarks` also reports, in `assignments`, the marks it invented for
+ * nodes that had none — the caller is expected to PERSIST those back onto
+ * `node.mark` the first time they are resolved in an edit session
+ * (`persistResolvedMarks`). That is what makes numbering stable under
+ * insertion: once written, an existing opening keeps its number forever and
+ * a newly inserted opening only ever takes the next free number. Without
+ * the write-back, inserting a door in the middle of a wall would silently
+ * renumber every door after it.
+ */
+export type OpeningMarkKind = 'door' | 'window';
+export type MarkResolution = {
+    /** Every door and window on the level → its mark. */
+    marks: ReadonlyMap<string, string>;
+    /** Only the marks that were invented (node.mark was empty). */
+    assignments: ReadonlyMap<string, string>;
+    /** Duplicate explicit marks and other reportable defects. */
+    issues: readonly string[];
+};
+export type MarkSceneInput = {
+    nodes: Readonly<Record<string, AnyNode>>;
+};
+/**
+ * Resolve marks for every door and window under `levelId`.
+ *
+ * `scene` may be a `{ nodes }` snapshot or the raw node map.
+ */
+export declare function resolveMarks(scene: MarkSceneInput | Readonly<Record<string, AnyNode>>, levelId: AnyNodeId): Map<string, string>;
+export declare function resolveMarkDetail(scene: MarkSceneInput | Readonly<Record<string, AnyNode>>, levelId: AnyNodeId): MarkResolution;
+/**
+ * Write invented marks back onto the nodes so numbering never drifts.
+ *
+ * Call once per level per edit session (the caller decides when — this
+ * module stays pure). `update` is typically `sceneApi.update`.
+ */
+export declare function persistResolvedMarks(resolution: MarkResolution, update: (id: AnyNodeId, data: Record<string, unknown>) => void): number;
+type Opening = (DoorNode | WindowNode) & {
+    type: 'door' | 'window';
+};
+/**
+ * Every door and window under the level, clockwise from the NW-most
+ * exterior wall, exterior walls first.
+ */
+export declare function orderedOpenings(nodes: Readonly<Record<string, AnyNode>>, levelId: AnyNodeId): Opening[];
+export {};
+//# sourceMappingURL=marks.d.ts.map

package/dist/lib/floorplan/marks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marks.d.ts","sourceRoot":"","sources":["../../../src/lib/floorplan/marks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAuB,UAAU,EAAE,MAAM,cAAc,CAAA;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,QAAQ,CAAA;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,qDAAqD;IACrD,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,+DAA+D;IAC/D,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,6DAA6D;IAC7D,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACzC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzD,OAAO,EAAE,SAAS,GACjB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAErB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzD,OAAO,EAAE,SAAS,GACjB,cAAc,CAkDhB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAC7D,MAAM,CAOR;AAID,KAAK,OAAO,GAAG,CAAC,QAAQ,GAAG,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AAEpE;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,GACjB,OAAO,EAAE,CAuCX"}

package/dist/lib/floorplan/marks.js

@@ -0,0 +1,157 @@
+/**
+ * Resolve marks for every door and window under `levelId`.
+ *
+ * `scene` may be a `{ nodes }` snapshot or the raw node map.
+ */
+export function resolveMarks(scene, levelId) {
+    return new Map(resolveMarkDetail(scene, levelId).marks);
+}
+export function resolveMarkDetail(scene, levelId) {
+    const nodes = normalizeNodes(scene);
+    const level = nodes[levelId];
+    const ordinal = level && level.type === 'level' ? (level.level ?? 0) : 0;
+    const base = (Math.max(0, ordinal) + 1) * 100;
+    const openings = orderedOpenings(nodes, levelId);
+    const marks = new Map();
+    const assignments = new Map();
+    const issues = [];
+    for (const kind of ['door', 'window']) {
+        const prefix = kind === 'door' ? 'D' : 'W';
+        const list = openings.filter((opening) => opening.type === kind);
+        const used = new Set();
+        const explicitOwners = new Map();
+        for (const opening of list) {
+            const explicit = opening.mark?.trim();
+            if (!explicit)
+                continue;
+            marks.set(opening.id, explicit);
+            const normalized = explicit.toLocaleUpperCase();
+            used.add(normalized);
+            const owners = explicitOwners.get(normalized);
+            if (owners)
+                owners.push(opening.id);
+            else
+                explicitOwners.set(normalized, [opening.id]);
+        }
+        let sequence = 1;
+        for (const opening of list) {
+            if (marks.has(opening.id))
+                continue;
+            let candidate = `${prefix}${base + sequence}`;
+            while (used.has(candidate.toLocaleUpperCase())) {
+                sequence++;
+                candidate = `${prefix}${base + sequence}`;
+            }
+            marks.set(opening.id, candidate);
+            assignments.set(opening.id, candidate);
+            used.add(candidate.toLocaleUpperCase());
+            sequence++;
+        }
+        for (const [mark, owners] of explicitOwners) {
+            if (owners.length > 1) {
+                issues.push(`Duplicate ${kind} mark ${mark} (${owners.length} instances)`);
+            }
+        }
+    }
+    return { marks, assignments, issues };
+}
+/**
+ * Write invented marks back onto the nodes so numbering never drifts.
+ *
+ * Call once per level per edit session (the caller decides when — this
+ * module stays pure). `update` is typically `sceneApi.update`.
+ */
+export function persistResolvedMarks(resolution, update) {
+    let written = 0;
+    for (const [id, mark] of resolution.assignments) {
+        update(id, { mark });
+        written++;
+    }
+    return written;
+}
+/**
+ * Every door and window under the level, clockwise from the NW-most
+ * exterior wall, exterior walls first.
+ */
+export function orderedOpenings(nodes, levelId) {
+    const walls = [];
+    const orphanOpenings = [];
+    const visit = (id) => {
+        const node = nodes[id];
+        if (!node)
+            return;
+        if (node.visible === false)
+            return;
+        if (node.type === 'wall')
+            walls.push(node);
+        else if (node.type === 'door' || node.type === 'window') {
+            const opening = node;
+            if (!opening.wallId || !nodes[opening.wallId])
+                orphanOpenings.push(opening);
+        }
+        for (const childId of node.children ?? [])
+            visit(childId);
+    };
+    visit(levelId);
+    const centroid = wallCentroid(walls);
+    const ordered = [...walls].sort((left, right) => {
+        const leftExterior = isExteriorWall(left) ? 0 : 1;
+        const rightExterior = isExteriorWall(right) ? 0 : 1;
+        if (leftExterior !== rightExterior)
+            return leftExterior - rightExterior;
+        return clockwiseKey(left, centroid) - clockwiseKey(right, centroid);
+    });
+    const result = [];
+    for (const wall of ordered) {
+        const wallOpenings = [];
+        for (const childId of wall.children ?? []) {
+            const child = nodes[childId];
+            if (child && child.visible !== false && (child.type === 'door' || child.type === 'window')) {
+                wallOpenings.push(child);
+            }
+        }
+        wallOpenings.sort((left, right) => left.position[0] - right.position[0]);
+        result.push(...wallOpenings);
+    }
+    result.push(...orphanOpenings);
+    return result;
+}
+function wallCentroid(walls) {
+    if (walls.length === 0)
+        return [0, 0];
+    let x = 0;
+    let z = 0;
+    for (const wall of walls) {
+        x += (wall.start[0] + wall.end[0]) / 2;
+        z += (wall.start[1] + wall.end[1]) / 2;
+    }
+    return [x / walls.length, z / walls.length];
+}
+/**
+ * Sweep key: 0 at the north-west direction, increasing clockwise on screen.
+ *
+ * Plan axes are x east, z south — z grows DOWN the screen — so a clockwise
+ * screen sweep (up → right → down → left) is the INCREASING atan2(z, x)
+ * direction. The north-west diagonal sits at atan2(-1, -1) = -3π/4, so
+ * anchoring there and wrapping into [0, 2π) yields north, east, south, west.
+ */
+const NORTH_WEST_ANGLE = (-3 * Math.PI) / 4;
+function clockwiseKey(wall, centroid) {
+    const midX = (wall.start[0] + wall.end[0]) / 2 - centroid[0];
+    const midZ = (wall.start[1] + wall.end[1]) / 2 - centroid[1];
+    let sweep = Math.atan2(midZ, midX) - NORTH_WEST_ANGLE;
+    while (sweep < 0)
+        sweep += Math.PI * 2;
+    while (sweep >= Math.PI * 2)
+        sweep -= Math.PI * 2;
+    return sweep;
+}
+function isExteriorWall(wall) {
+    return wall.frontSide === 'exterior' || wall.backSide === 'exterior';
+}
+function normalizeNodes(scene) {
+    const candidate = scene;
+    return candidate && typeof candidate === 'object' && 'nodes' in candidate
+        ? candidate.nodes
+        : scene;
+}

package/dist/lib/floorplan/plan-math.d.ts

@@ -0,0 +1,18 @@
+import { type WallJustification } from '../../systems/wall/wall-frame.js';
+import type { Point2D } from '../../systems/wall/wall-mitering.js';
+export declare const FLOORPLAN_VIEW_ROTATION_DEG = 0;
+export declare function clampPlanValue(value: number, min: number, max: number): number;
+export declare function rotatePlanVector(x: number, y: number, rotation: number): [number, number];
+export declare function worldToFloorplanLocalPoint(worldX: number, worldZ: number, buildingPosition: readonly [number, number, number], buildingRotationY: number): Point2D;
+export declare function floorplanLocalToWorldPoint(point: Point2D | [number, number], buildingPosition: readonly [number, number, number], buildingRotationY: number): {
+    x: number;
+    z: number;
+};
+export declare function interpolatePlanPoint(start: Point2D, end: Point2D, t: number): Point2D;
+export declare function getPlanPointDistance(start: Point2D, end: Point2D): number;
+export declare function movePlanPointTowards(start: Point2D, end: Point2D, distance: number): Point2D;
+export declare function getThickPlanLinePolygon(line: {
+    start: Point2D;
+    end: Point2D;
+}, thickness: number, justification?: WallJustification): Point2D[];
+//# sourceMappingURL=plan-math.d.ts.map

package/dist/lib/floorplan/plan-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-math.d.ts","sourceRoot":"","sources":["../../../src/lib/floorplan/plan-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AAC1F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAA;AAY/D,eAAO,MAAM,2BAA2B,IAAI,CAAA;AAE5C,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,UAErE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIzF;AAQD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACnD,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAUT;AAGD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,gBAAgB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACnD,iBAAiB,EAAE,MAAM,GACxB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAU1B;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAKrF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAEzE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAO5F;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,EACtC,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,iBAAiB,GAChC,OAAO,EAAE,CAqBX"}

package/dist/lib/floorplan/plan-math.js

@@ -0,0 +1,82 @@
+import { getWallFaceOffsets } from '../../systems/wall/wall-frame.js';
+// Baseline rotation (deg) that orients the plan-local scene "north up" on
+// screen. The on-screen floor-plan scene `<g>` is rotated by
+// `FLOORPLAN_VIEW_ROTATION_DEG + userRotation - buildingRotation`; PDF export
+// uses the same user rotation so its orientation matches the live plan.
+//
+// North is world −Z: with a 0 baseline a rotation-0 reference image (top =
+// −Z) reads upright in the north-aligned view, and "align north" maps to a
+// 3D camera azimuth of 0. The old 90° baseline made north world −X, so
+// north-up floorplan scans displayed sideways whenever the compass claimed
+// the view was aligned.
+export const FLOORPLAN_VIEW_ROTATION_DEG = 0;
+export function clampPlanValue(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+export function rotatePlanVector(x, y, rotation) {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [x * cos + y * sin, -x * sin + y * cos];
+}
+// Converts a world X/Z point into the floor-plan-local (building-local)
+// frame used by the SVG scene `<g>` and every stored node position. The
+// inverse of `floorplanLocalToWorldPoint`. Shared so the floor-plan panel
+// and the 2D move overlay resolve the same frame — feeding a world-space
+// `original` into a local-space cursor solver lands the drop off by the
+// building's world X/Z (worse for an off-origin building).
+export function worldToFloorplanLocalPoint(worldX, worldZ, buildingPosition, buildingRotationY) {
+    const dx = worldX - buildingPosition[0];
+    const dz = worldZ - buildingPosition[2];
+    const cos = Math.cos(buildingRotationY);
+    const sin = Math.sin(buildingRotationY);
+    return {
+        x: dx * cos - dz * sin,
+        y: dx * sin + dz * cos,
+    };
+}
+// Inverse of `worldToFloorplanLocalPoint`: floor-plan-local X/Y → world X/Z.
+export function floorplanLocalToWorldPoint(point, buildingPosition, buildingRotationY) {
+    const localX = Array.isArray(point) ? point[0] : point.x;
+    const localY = Array.isArray(point) ? point[1] : point.y;
+    const cos = Math.cos(buildingRotationY);
+    const sin = Math.sin(buildingRotationY);
+    return {
+        x: buildingPosition[0] + localX * cos + localY * sin,
+        z: buildingPosition[2] - localX * sin + localY * cos,
+    };
+}
+export function interpolatePlanPoint(start, end, t) {
+    return {
+        x: start.x + (end.x - start.x) * t,
+        y: start.y + (end.y - start.y) * t,
+    };
+}
+export function getPlanPointDistance(start, end) {
+    return Math.hypot(end.x - start.x, end.y - start.y);
+}
+export function movePlanPointTowards(start, end, distance) {
+    const totalDistance = getPlanPointDistance(start, end);
+    if (totalDistance <= Number.EPSILON || distance <= 0) {
+        return start;
+    }
+    return interpolatePlanPoint(start, end, Math.min(1, distance / totalDistance));
+}
+export function getThickPlanLinePolygon(line, thickness, justification) {
+    const dx = line.end.x - line.start.x;
+    const dy = line.end.y - line.start.y;
+    const length = Math.hypot(dx, dy);
+    if (length <= Number.EPSILON || thickness <= 0) {
+        return [line.start, line.end, line.end, line.start];
+    }
+    const { a, b } = getWallFaceOffsets({ thickness, justification });
+    const normalX = (-dy / length) * a;
+    const normalY = (dx / length) * a;
+    const backX = (-dy / length) * -b;
+    const backY = (dx / length) * -b;
+    return [
+        { x: line.start.x + normalX, y: line.start.y + normalY },
+        { x: line.end.x + normalX, y: line.end.y + normalY },
+        { x: line.end.x - backX, y: line.end.y - backY },
+        { x: line.start.x - backX, y: line.start.y - backY },
+    ];
+}

package/dist/lib/floorplan/svg-paths.d.ts

@@ -0,0 +1,17 @@
+import type { Point2D } from '../../systems/wall/wall-mitering.js';
+export declare function formatPolygonPath(points: Point2D[], holes?: Point2D[][]): string;
+export declare function buildSvgPolylinePath(points: Point2D[]): string | null;
+export declare function getArcPlanPoint(center: Point2D, radius: number, angle: number): Point2D;
+export declare function buildSvgArcPath(center: Point2D, radius: number, startAngle: number, endAngle: number): string;
+export declare function buildSvgAnnularSectorPath(center: Point2D, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number): string;
+export declare function formatSvgPolygonPoints(points: Point2D[]): string;
+/**
+ * Three points defining an arrow head — tip + two trailing barbs.
+ * Returned as plain `Point2D` objects so consumers can either feed them
+ * straight into `formatSvgPolygonPoints` (for SVG `points=""`) or push
+ * them onto a `FloorplanGeometry.polygon.points` array. Mixing both
+ * downstream paths through a string-returning helper was awkward — see
+ * `nodes/src/stair/floorplan.ts` which needs the points as objects.
+ */
+export declare function buildSvgArrowHeadPoints(point: Point2D, angle: number, size: number): Point2D[];
+//# sourceMappingURL=svg-paths.d.ts.map

package/dist/lib/floorplan/svg-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg-paths.d.ts","sourceRoot":"","sources":["../../../src/lib/floorplan/svg-paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAA;AAiB/D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,KAAK,GAAE,OAAO,EAAE,EAAO,UAoB3E;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,iBAWrD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAKvF;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,UAIjB;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,UAWjB;AAWD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,UAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAW9F"}

package/dist/lib/floorplan/svg-paths.js

@@ -0,0 +1,92 @@
+function toSvgX(value) {
+    return value;
+}
+function toSvgY(value) {
+    return value;
+}
+function toSvgPoint(point) {
+    return {
+        x: toSvgX(point.x),
+        y: toSvgY(point.y),
+    };
+}
+export function formatPolygonPath(points, holes = []) {
+    const formatSubpath = (subpathPoints) => {
+        const [firstPoint, ...restPoints] = subpathPoints;
+        if (!firstPoint) {
+            return null;
+        }
+        const firstSvgPoint = toSvgPoint(firstPoint);
+        return [
+            `M ${firstSvgPoint.x} ${firstSvgPoint.y}`,
+            ...restPoints.map((point) => {
+                const svgPoint = toSvgPoint(point);
+                return `L ${svgPoint.x} ${svgPoint.y}`;
+            }),
+            'Z',
+        ].join(' ');
+    };
+    return [points, ...holes].map(formatSubpath).filter(Boolean).join(' ');
+}
+export function buildSvgPolylinePath(points) {
+    if (points.length < 2) {
+        return null;
+    }
+    return points
+        .map((point, index) => {
+        const svgPoint = toSvgPoint(point);
+        return `${index === 0 ? 'M' : 'L'} ${svgPoint.x} ${svgPoint.y}`;
+    })
+        .join(' ');
+}
+export function getArcPlanPoint(center, radius, angle) {
+    return {
+        x: center.x + Math.cos(angle) * radius,
+        y: center.y + Math.sin(angle) * radius,
+    };
+}
+export function buildSvgArcPath(center, radius, startAngle, endAngle) {
+    const start = getArcPlanPoint(center, radius, startAngle);
+    return `M ${toSvgX(start.x)} ${toSvgY(start.y)} ${svgArcCommands(center, radius, startAngle, endAngle)}`;
+}
+export function buildSvgAnnularSectorPath(center, innerRadius, outerRadius, startAngle, endAngle) {
+    const outerStart = getArcPlanPoint(center, outerRadius, startAngle);
+    const innerEnd = getArcPlanPoint(center, innerRadius, endAngle);
+    return [
+        `M ${toSvgX(outerStart.x)} ${toSvgY(outerStart.y)}`,
+        svgArcCommands(center, outerRadius, startAngle, endAngle),
+        `L ${toSvgX(innerEnd.x)} ${toSvgY(innerEnd.y)}`,
+        svgArcCommands(center, innerRadius, endAngle, startAngle),
+        'Z',
+    ].join(' ');
+}
+function svgArcCommands(center, radius, startAngle, endAngle) {
+    const delta = endAngle - startAngle;
+    const count = Math.max(1, Math.ceil(Math.abs(delta) / Math.PI));
+    return Array.from({ length: count }, (_, index) => {
+        const end = getArcPlanPoint(center, radius, startAngle + (delta * (index + 1)) / count);
+        return `A ${radius} ${radius} 0 0 ${delta >= 0 ? 1 : 0} ${toSvgX(end.x)} ${toSvgY(end.y)}`;
+    }).join(' ');
+}
+export function formatSvgPolygonPoints(points) {
+    return points.map((point) => `${toSvgX(point.x)},${toSvgY(point.y)}`).join(' ');
+}
+/**
+ * Three points defining an arrow head — tip + two trailing barbs.
+ * Returned as plain `Point2D` objects so consumers can either feed them
+ * straight into `formatSvgPolygonPoints` (for SVG `points=""`) or push
+ * them onto a `FloorplanGeometry.polygon.points` array. Mixing both
+ * downstream paths through a string-returning helper was awkward — see
+ * `nodes/src/stair/floorplan.ts` which needs the points as objects.
+ */
+export function buildSvgArrowHeadPoints(point, angle, size) {
+    const left = {
+        x: point.x - size * Math.cos(angle - Math.PI / 6),
+        y: point.y - size * Math.sin(angle - Math.PI / 6),
+    };
+    const right = {
+        x: point.x - size * Math.cos(angle + Math.PI / 6),
+        y: point.y - size * Math.sin(angle + Math.PI / 6),
+    };
+    return [point, left, right];
+}

package/dist/lib/floorplan/wall-affordances.d.ts

@@ -0,0 +1,31 @@
+import type { WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from '../../systems/wall/wall-move.js';
+/** The floor plan's affordance id for a wall end's pull grip (a `move-arrow`, variant `pull`). */
+export declare const WALL_PULL_AFFORDANCE = "wall-pull";
+/** What a pull grip carries: the wall, and which of its ends it pulls from. */
+export type WallPullGripPayload = {
+    wallId: string;
+    endpoint: 'start' | 'end';
+};
+/** The grip's tooltip, in both views. */
+export declare const WALL_PULL_GRIP_TITLE = "Drag to draw the next wall";
+/**
+ * The pulled end of `wall` and the direction out of it: along the wall for a
+ * straight one, along its tangent for a curved one.
+ */
+export declare function wallPullSeed(wall: Pick<WallNode, 'start' | 'end' | 'curveOffset'>, endpoint: 'start' | 'end'): {
+    start: WallPlanPoint;
+    reference: WallPlanPoint;
+} | null;
+/**
+ * The affordance a floor-plan `move-arrow` carries to be a wall push arrow;
+ * its payload is a `WallPushArrowPayload`. The editor's floor plan runs its
+ * wall push for it instead of a registry affordance session.
+ */
+export declare const WALL_PUSH_AFFORDANCE = "wall-push";
+/** A wall's or an invisible wall's side arrow: `wallId` is either. */
+export type WallPushArrowPayload = {
+    wallId: string;
+    side: 'a' | 'b';
+};
+//# sourceMappingURL=wall-affordances.d.ts.map

package/dist/lib/floorplan/wall-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-affordances.d.ts","sourceRoot":"","sources":["../../../src/lib/floorplan/wall-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAEjE,kGAAkG;AAClG,eAAO,MAAM,oBAAoB,cAAc,CAAA;AAE/C,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAAE,CAAA;AAE/E,yCAAyC;AACzC,eAAO,MAAM,oBAAoB,+BAA+B,CAAA;AAEhE;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,EACrD,QAAQ,EAAE,OAAO,GAAG,KAAK,GACxB;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,SAAS,EAAE,aAAa,CAAA;CAAE,GAAG,IAAI,CAQ3D;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,cAAc,CAAA;AAE/C,sEAAsE;AACtE,MAAM,MAAM,oBAAoB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,CAAA"}

package/dist/lib/floorplan/wall-affordances.js

@@ -0,0 +1,24 @@
+import { getWallCurveFrameAt } from '../../systems/wall/wall-curve.js';
+/** The floor plan's affordance id for a wall end's pull grip (a `move-arrow`, variant `pull`). */
+export const WALL_PULL_AFFORDANCE = 'wall-pull';
+/** The grip's tooltip, in both views. */
+export const WALL_PULL_GRIP_TITLE = 'Drag to draw the next wall';
+/**
+ * The pulled end of `wall` and the direction out of it: along the wall for a
+ * straight one, along its tangent for a curved one.
+ */
+export function wallPullSeed(wall, endpoint) {
+    const start = endpoint === 'start' ? [wall.start[0], wall.start[1]] : [wall.end[0], wall.end[1]];
+    const tangent = getWallCurveFrameAt(wall, endpoint === 'start' ? 0 : 1).tangent;
+    const sign = endpoint === 'start' ? -1 : 1;
+    const length = Math.hypot(tangent.x, tangent.y);
+    if (!(length > 1e-9))
+        return null;
+    return { start, reference: [(tangent.x / length) * sign, (tangent.y / length) * sign] };
+}
+/**
+ * The affordance a floor-plan `move-arrow` carries to be a wall push arrow;
+ * its payload is a `WallPushArrowPayload`. The editor's floor plan runs its
+ * wall push for it instead of a registry affordance session.
+ */
+export const WALL_PUSH_AFFORDANCE = 'wall-push';

package/dist/lib/hierarchy.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId } from '../schema/types.js';
+type NodeMap = Readonly<Record<string, Pick<AnyNode, 'parentId'>>>;
+type NodeLookup = (id: AnyNodeId) => Pick<AnyNode, 'parentId'> | undefined;
+/**
+ * Whether assigning `newParentId` to `nodeId` would put `nodeId` on a cycle of
+ * parent links. A cycle the chain already holds without `nodeId` is not one it
+ * creates: counting it would refuse every edit beneath an old cyclic scene.
+ */
+export declare function wouldCreateHierarchyCycle(nodeId: AnyNodeId, newParentId: AnyNodeId | null, nodes: NodeMap | NodeLookup): boolean;
+/** Return each distinct cycle encoded by `parentId` links. */
+export declare function findHierarchyCycles(nodes: NodeMap): AnyNodeId[][];
+/** The `parentId` error each node on a cycle raises, as every scene check lists it. */
+export declare function hierarchyCycleErrors(nodes: NodeMap): {
+    nodeId: AnyNodeId;
+    path: 'parentId';
+    message: string;
+}[];
+export {};
+//# sourceMappingURL=hierarchy.d.ts.map

package/dist/lib/hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hierarchy.d.ts","sourceRoot":"","sources":["../../src/lib/hierarchy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,KAAK,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;AAClE,KAAK,UAAU,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,SAAS,CAAA;AAE1E;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,SAAS,GAAG,IAAI,EAC7B,KAAK,EAAE,OAAO,GAAG,UAAU,GAC1B,OAAO,CAaT;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,EAAE,CAwBjE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CAK5D"}

package/dist/lib/hierarchy.js

@@ -0,0 +1,53 @@
+/**
+ * Whether assigning `newParentId` to `nodeId` would put `nodeId` on a cycle of
+ * parent links. A cycle the chain already holds without `nodeId` is not one it
+ * creates: counting it would refuse every edit beneath an old cyclic scene.
+ */
+export function wouldCreateHierarchyCycle(nodeId, newParentId, nodes) {
+    if (!newParentId)
+        return false;
+    const nodeAt = typeof nodes === 'function' ? nodes : (id) => nodes[id];
+    const seen = new Set();
+    let currentId = newParentId;
+    while (currentId) {
+        if (currentId === nodeId)
+            return true;
+        if (seen.has(currentId))
+            return false;
+        seen.add(currentId);
+        currentId = nodeAt(currentId)?.parentId ?? null;
+    }
+    return false;
+}
+/** Return each distinct cycle encoded by `parentId` links. */
+export function findHierarchyCycles(nodes) {
+    const visited = new Set();
+    const cycles = [];
+    for (const startId of Object.keys(nodes)) {
+        if (visited.has(startId))
+            continue;
+        const chain = [];
+        const positions = new Map();
+        let currentId = startId;
+        while (currentId && nodes[currentId] && !visited.has(currentId)) {
+            const position = positions.get(currentId);
+            if (position !== undefined) {
+                cycles.push(chain.slice(position));
+                break;
+            }
+            positions.set(currentId, chain.length);
+            chain.push(currentId);
+            currentId = nodes[currentId]?.parentId ?? null;
+        }
+        for (const id of chain)
+            visited.add(id);
+    }
+    return cycles;
+}
+/** The `parentId` error each node on a cycle raises, as every scene check lists it. */
+export function hierarchyCycleErrors(nodes) {
+    return findHierarchyCycles(nodes).flatMap((cycle) => {
+        const message = `hierarchy cycle detected: ${[...cycle, cycle[0]].join(' -> ')}`;
+        return cycle.map((nodeId) => ({ nodeId, path: 'parentId', message }));
+    });
+}

package/dist/lib/opening-floor-datum.d.ts

@@ -5,7 +5,7 @@ export declare function supportSegmentAt(segment: WallSlabSupportSegment, t: num
 export declare function openingDatumFromSupport(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'> & Partial<Pick<DoorNode, 'rotation' | 'sidelightLeft' | 'sidelightRight' | 'transomHeight' | 'doorType'>>, support: WallSlabSupport): number;
 /** Unclamped floor intent, used by authoring feasibility and legacy migration. */
 export declare function getOpeningFloorTarget(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'> & Partial<Pick<DoorNode, 'rotation' | 'sidelightLeft' | 'sidelightRight' | 'transomHeight' | 'doorType'>>, nodes: Readonly<Record<string, AnyNode>>): number;
-export declare function openingFitsAtDatum(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'height'> & Partial<Pick<DoorNode, 'transomHeight' | 'doorType'>>, datum: number, nodes: Readonly<Record<string, AnyNode>>, support?: WallSlabSupport): boolean;
+export declare function openingFitsAtDatum(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'> & Partial<Pick<DoorNode, 'transomHeight' | 'doorType'>>, datum: number, nodes: Readonly<Record<string, AnyNode>>, support?: WallSlabSupport): boolean;
 /**
  * The lowest the wall reaches under the opening's span, level-local, on its centreline or either
  * face: where a face goes down beside a floor sunk under the one the wall stands on (a garage

package/dist/lib/opening-floor-datum.d.ts.map

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

package/dist/lib/opening-floor-datum.js

@@ -1,4 +1,4 @@
-import { getWallTop } from '../services/storey.js';
+import { getWallTopOver } from '../services/storey.js';
 import { computeWallSlabSupport, } from '../systems/slab/slab-support.js';
 import { getWallCurveFrameAt, getWallCurveLength } from '../systems/wall/wall-curve.js';
 import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
@@ -64,7 +64,7 @@ export function getOpeningFloorTarget(wall, opening, nodes) {
     return openingDatumFromSupport(wall, opening, wallSupportForNodes(wall, nodes));
 }
 export function openingFitsAtDatum(wall, opening, datum, nodes, support = wallSupportForNodes(wall, nodes)) {
-    const top = getWallTop(wall, wall.parentId, nodes, support.elevation);
+    const top = getWallTopOver(wall, wall.parentId, nodes, support.elevation, opening.position[0] - opening.width / 2, opening.position[0] + opening.width / 2);
     return (datum +
         opening.position[1] -
         opening.height / 2 +

package/dist/lib/own-floor-intent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"own-floor-intent.d.ts","sourceRoot":"","sources":["../../src/lib/own-floor-intent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAsB,MAAM,WAAW,CAAA;AAavE,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAEvD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE;aAKT,MAAM,EAAE;;;;;;EA+N1B"}
+{"version":3,"file":"own-floor-intent.d.ts","sourceRoot":"","sources":["../../src/lib/own-floor-intent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAsB,MAAM,WAAW,CAAA;AAavE,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAEvD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE;aAKT,MAAM,EAAE;;;;;;EAqO1B"}