@pascal-app/core 1.1.0 → 1.1.2

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/steps.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Work in steps: each resume runs the next piece, and the last returns the result. A long
+ * computation written this way can be resumed one piece at a time by a caller that lets other work
+ * run in between; `inOneGo` runs it through.
+ */
+export type Steps<Result> = Generator<void, Result, void>;
+export declare function inOneGo<Result>(steps: Steps<Result>): Result;
+//# sourceMappingURL=steps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../src/lib/steps.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;AAEzD,wBAAgB,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAK5D"}

package/dist/lib/steps.js

@@ -0,0 +1,7 @@
+export function inOneGo(steps) {
+    for (;;) {
+        const step = steps.next();
+        if (step.done)
+            return step.value;
+    }
+}

package/dist/registry/__fixtures__/roof-planes.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import type { AnyNode } from '../../schema/types.js';
+/**
+ * A plugin's solved roof plane, as an architect's roof holds it (`capabilities.roofs`): an outline
+ * in its roof's plan, rising from a baseline at a pitch (rise per 12 of run).
+ */
+export declare const RoofPlane: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`roofplane_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"test:roof-plane">>;
+    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    baseline: z.ZodTuple<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>], null>;
+    baseHeight: z.ZodNumber;
+    pitch: z.ZodNumber;
+}, z.core.$strip>;
+export type RoofPlane = z.infer<typeof RoofPlane>;
+/** The plane's surface over its roof's origin at a plan point: its eave, plus the rise of the run off it. */
+export declare function roofPlaneHeightAt(plane: RoofPlane, x: number, z: number): number;
+/** Registers the planes' kind; the test setup restores the registry after each test. */
+export declare function registerRoofPlanes(): void;
+/**
+ * A plane over the plan rectangle [x0, z0] to [x1, z1] of its roof, its eave along z0 at `eave`,
+ * rising toward z1 at `pitch` in 12.
+ */
+export declare function roofPlane(id: string, [x0, z0, x1, z1]: [number, number, number, number], eave: number, { pitch, parentId }?: {
+    pitch?: number;
+    parentId?: string | null;
+}): AnyNode;
+//# sourceMappingURL=roof-planes.d.ts.map

package/dist/registry/__fixtures__/roof-planes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-planes.d.ts","sourceRoot":"","sources":["../../../src/registry/__fixtures__/roof-planes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAMjD;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD,6GAA6G;AAC7G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIhF;AAOD,wFAAwF;AACxF,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClD,IAAI,EAAE,MAAM,EACZ,EAAE,KAAS,EAAE,QAAe,EAAE,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAChF,OAAO,CAiBT"}

package/dist/registry/__fixtures__/roof-planes.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../../schema/base.js';
+import { registerNode } from '../registry.js';
+const Pt = z.tuple([z.number(), z.number()]);
+/**
+ * A plugin's solved roof plane, as an architect's roof holds it (`capabilities.roofs`): an outline
+ * in its roof's plan, rising from a baseline at a pitch (rise per 12 of run).
+ */
+export const RoofPlane = BaseNode.extend({
+    id: objectId('roofplane'),
+    type: nodeType('test:roof-plane'),
+    polygon: z.array(Pt),
+    baseline: z.tuple([Pt, Pt]),
+    baseHeight: z.number(),
+    pitch: z.number(),
+});
+/** The plane's surface over its roof's origin at a plan point: its eave, plus the rise of the run off it. */
+export function roofPlaneHeightAt(plane, x, z) {
+    const [[ax, az], [bx, bz]] = plane.baseline;
+    const run = Math.abs((x - ax) * (bz - az) - (z - az) * (bx - ax)) / Math.hypot(bx - ax, bz - az);
+    return plane.baseHeight + (run * plane.pitch) / 12;
+}
+const roofs = {
+    outline: (node) => node.polygon,
+    heightAt: (node, x, z) => roofPlaneHeightAt(node, x, z),
+};
+/** Registers the planes' kind; the test setup restores the registry after each test. */
+export function registerRoofPlanes() {
+    registerNode({
+        kind: 'test:roof-plane',
+        schemaVersion: 1,
+        schema: RoofPlane,
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: { roofs },
+    });
+}
+/**
+ * A plane over the plan rectangle [x0, z0] to [x1, z1] of its roof, its eave along z0 at `eave`,
+ * rising toward z1 at `pitch` in 12.
+ */
+export function roofPlane(id, [x0, z0, x1, z1], eave, { pitch = 6, parentId = null } = {}) {
+    return RoofPlane.parse({
+        id,
+        parentId,
+        polygon: [
+            [x0, z0],
+            [x1, z0],
+            [x1, z1],
+            [x0, z1],
+        ],
+        baseline: [
+            [x0, z0],
+            [x1, z0],
+        ],
+        baseHeight: eave,
+        pitch,
+    });
+}

package/dist/registry/index.d.ts

@@ -2,8 +2,9 @@ export type { ArcResizeHandle, CornerRadiusHandle, Cursor, EditorApi, EndpointMo
 export { nodeMechanism, nodeMechanismParts, toggleMechanism, toggleMechanismPart, toggleNodeMechanism, } from './mechanism.js';
 export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, floorPlacedCollides, getHostRefFields, getInspectorExtensions, getNodePluginId, getRegistryVersion, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeDuplicable, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, isSelectionHighlightEnabled, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, onRegistryChange, type PluginDiscovery, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry.js';
 export { type CascadeContext, type ChildQuery, cascadeDirty, collectDescendants, type SpatialQuery, } from './relations-resolver.js';
+export { type RoofFaceShape, roofFaceOf, roofFaceShapes, validateRoofRelations } from './roofs.js';
 export { createSceneApi, type SceneStoreLike, type SceneToolHost } from './scene-api.js';
 export { type CloneNodesIntoOptions, type CloneNodesIntoResult, cloneNodesInto, collectSubtree, type Subtree, withoutSourceIdentity, } from './subtree.js';
-export type { Affordance, AlignmentFootprint, AlignmentFootprintConfig, AnyNodeDefinition, AssemblyHostConfig, AssemblyReference, AssetRef, BakeGeometryAsyncBuilder, BakeGeometryBuilder, BakePolicy, BakeReplaceRenderer, BatchableConfig, Capabilities, CapabilityCtx, CutsContext, CuttableConfig, DimensionTerminator, DimensionTextPosition, DistributionRole, DragAction, DuplicableConfig, DuplicateSubtreeCloneArgs, DuplicateSubtreeCloneResult, EditorCtx, EvaluationContext, ExportAnimationContext, ExportProfile, FaceHostCapability, FaceHostPlacementArgs, FaceHostPlacementResult, FaceHostStoredPlacementArgs, FaceHostStoredValidityArgs, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanScope, FloorplanStyle, GeometryContext, GridSnapPositionArgs, GroupMoveSnapArgs, GroupMoveSnapResult, HostableConfig, IconRef, InspectorExtension, Issue, KeyboardAction, KeyboardActions, LazyComponent, LiveTransformLike, McpOverrides, MeasurementContribution, MeasurementFeature, MeasurementFeatureBinding, MeasurementFeatureGeometry, MeasurementSnapKind, MechanismCapability, MechanismPart, Modifiers, MovableConfig, MovableParentFrame, NodeCategory, NodeDefinition, NodePort, NodeQuickAction, NodeQuickActionIcon, NodeQuickActionNodeScope, NodeQuickActionProvider, NodeQuickActionResult, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, PaintScopeId, PaintSurfaceScopes, ParamAction, ParametricDescriptor, ParamField, ParamGroup, ParentFrameSnapMatch, PascalBakeExtras, PascalPartTag, PlacementNotice, Plugin, PortRef, Presentation, QuickMeasurementMetric, QuickMeasurementQuantity, QuickMeasurementReport, ReferenceDeclaration, ReferenceDeletePolicy, ReferenceNamespace, ReferencePath, ReferencePresetPolicy, ReferenceRole, Relations, RendererSource, RevealClears, RevealConfig, RevealLayout, RevealPhase, RevealPlanPoint, RevealStyle, RoofAccessoryConfig, RotatableConfig, ScalableConfig, SceneActionCapability, SceneApi, SelectableConfig, SlotDeclaration, SnapPointKind, SnapProfile, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, ToolHintChip, ToolOption, ToolOptionChoice, Vec2, } from './types.js';
+export type { Affordance, AlignmentFootprint, AlignmentFootprintConfig, AnyNodeDefinition, AssemblyHostConfig, AssemblyReference, AssetRef, BakeGeometryAsyncBuilder, BakeGeometryBuilder, BakePolicy, BakeReplaceRenderer, BatchableConfig, Capabilities, CapabilityCtx, CutsContext, CuttableConfig, DimensionTerminator, DimensionTextPosition, DistributionRole, DragAction, DuplicableConfig, DuplicateSubtreeCloneArgs, DuplicateSubtreeCloneResult, EditorCtx, EvaluationContext, ExportAnimationContext, ExportProfile, FaceHostCapability, FaceHostPlacementArgs, FaceHostPlacementResult, FaceHostStoredPlacementArgs, FaceHostStoredValidityArgs, FloorPlacedConfig, FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, FloorplanAffordance, FloorplanAffordanceModifiers, FloorplanAffordancePoint, FloorplanAffordanceSession, FloorplanGeometry, FloorplanMoveTarget, FloorplanMoveTargetSession, FloorplanPalette, FloorplanPoint, FloorplanScope, FloorplanStyle, GeometryContext, GridSnapPositionArgs, GroupMoveSnapArgs, GroupMoveSnapResult, HostableConfig, IconRef, InspectorExtension, Issue, KeyboardAction, KeyboardActions, LazyComponent, LiveTransformLike, McpOverrides, MeasurementContribution, MeasurementFeature, MeasurementFeatureBinding, MeasurementFeatureGeometry, MeasurementSnapKind, MechanismCapability, MechanismPart, Modifiers, MovableConfig, MovableParentFrame, NodeCategory, NodeDefinition, NodePort, NodeQuickAction, NodeQuickActionIcon, NodeQuickActionNodeScope, NodeQuickActionProvider, NodeQuickActionResult, NodeRegistry, PaintCapability, PaintEffectiveMaterialArgs, PaintPatchArgs, PaintPreviewArgs, PaintResolveArgs, PaintScopeId, PaintSurfaceScopes, ParamAction, ParametricDescriptor, ParamField, ParamGroup, ParentFrameSnapMatch, PascalBakeExtras, PascalPartTag, PlacementNotice, Plugin, PortRef, Presentation, QuickMeasurementMetric, QuickMeasurementQuantity, QuickMeasurementReport, ReferenceDeclaration, ReferenceDeletePolicy, ReferenceNamespace, ReferencePath, ReferencePresetPolicy, ReferenceRole, Relations, RendererSource, RevealClears, RevealConfig, RevealLayout, RevealPhase, RevealPlanPoint, RevealStyle, RoofAccessoryConfig, RoofsCapability, RotatableConfig, ScalableConfig, SceneActionCapability, SceneApi, SelectableConfig, SlotDeclaration, SnapPointKind, SnapProfile, SnappableConfig, SnapServicesLike, SurfacePoint, SurfaceQuery, SurfaceRole, SurfacesConfig, SystemContribution, ToolHint, ToolHintChip, ToolOption, ToolOptionChoice, Vec2, } from './types.js';
 export { validateNodeRelations } from './validate-relations.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/registry/index.d.ts.map

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

package/dist/registry/index.js

@@ -1,6 +1,7 @@
 export { nodeMechanism, nodeMechanismParts, toggleMechanism, toggleMechanismPart, toggleNodeMechanism, } from './mechanism.js';
 export { bakePolicyOf, discoverPlugins, extendPluginDiscovery, floorPlacedCollides, getHostRefFields, getInspectorExtensions, getNodePluginId, getRegistryVersion, getSelectableKinds, hasRegistry3DMoveTool, isDrawnViaTool, isDrawnViaToolKind, isNodeDuplicable, isNodeKindEnabled, isPresettable, isPresettableKind, isRegistryMovable, isRegistrySelectable, isSelectionHighlightEnabled, kindsWithBakePolicy, kindsWithFloorplanScope, loadPlugin, nodeRegistry, onRegistryChange, registerNode, resolveFacingIndicator, setPluginDiscovery, } from './registry.js';
 export { cascadeDirty, collectDescendants, } from './relations-resolver.js';
+export { roofFaceOf, roofFaceShapes, validateRoofRelations } from './roofs.js';
 export { createSceneApi } from './scene-api.js';
 export { cloneNodesInto, collectSubtree, withoutSourceIdentity, } from './subtree.js';
 export { validateNodeRelations } from './validate-relations.js';

package/dist/registry/roofs.d.ts

@@ -0,0 +1,34 @@
+import type { AnyNode, RoofNode } from '../schema/index.js';
+import type { RoofsCapability } from './types.js';
+type Nodes = Readonly<Record<string, AnyNode | undefined>>;
+type Pt = [number, number];
+/**
+ * The node's `roofs` capability, when its kind declares one: the node is a face of the roof holding
+ * it. Undefined for a roof's segments, which are its masses, and for kinds this runtime has not
+ * registered.
+ */
+export declare function roofFaceOf(node: AnyNode | undefined): RoofsCapability | undefined;
+/** A face of a roof in the frame of what holds the roof: its level's metres. */
+export type RoofFaceShape = {
+    id: string;
+    /** The face's outline in that plan, `[x, z]` corners. */
+    outline: Pt[];
+    /** Its surface at its lowest corner (the eave) and at its highest, over that frame's floor. */
+    low: number;
+    high: number;
+};
+/**
+ * A roof's faces (`capabilities.roofs`), in `children` order, each in the plan and heights of what
+ * holds the roof: the roof's turn and position applied to the face's own frame. A face of a kind
+ * this runtime has not registered, or one with no area, is not read.
+ */
+export declare function roofFaceShapes(roof: RoofNode, nodes: Nodes): RoofFaceShape[];
+/**
+ * A roof holds its segments and faces of other kinds (`capabilities.roofs`), nothing else: a child
+ * a write adds to it, of a registered kind that is neither, is refused. What it held before stays,
+ * so a roof saved before the rule still edits, and so does a kind this runtime has not registered
+ * (a plugin loaded elsewhere).
+ */
+export declare function validateRoofRelations(roof: AnyNode, nodes: Nodes, before?: Nodes): void;
+export {};
+//# sourceMappingURL=roofs.d.ts.map

package/dist/registry/roofs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roofs.d.ts","sourceRoot":"","sources":["../../src/registry/roofs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;AAC1D,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1B;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAEjF;AAED,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,yDAAyD;IACzD,OAAO,EAAE,EAAE,EAAE,CAAA;IACb,+FAA+F;IAC/F,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,aAAa,EAAE,CA0B5E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,CAavF"}

package/dist/registry/roofs.js

@@ -0,0 +1,61 @@
+import { nodeRegistry } from './registry.js';
+/**
+ * The node's `roofs` capability, when its kind declares one: the node is a face of the roof holding
+ * it. Undefined for a roof's segments, which are its masses, and for kinds this runtime has not
+ * registered.
+ */
+export function roofFaceOf(node) {
+    return node ? nodeRegistry.get(node.type)?.capabilities.roofs : undefined;
+}
+/**
+ * A roof's faces (`capabilities.roofs`), in `children` order, each in the plan and heights of what
+ * holds the roof: the roof's turn and position applied to the face's own frame. A face of a kind
+ * this runtime has not registered, or one with no area, is not read.
+ */
+export function roofFaceShapes(roof, nodes) {
+    // The roof's turn about +Y, as three.js turns its group: local +z toward +x.
+    const cos = Math.cos(roof.rotation ?? 0);
+    const sin = Math.sin(roof.rotation ?? 0);
+    const [x0, y0, z0] = roof.position;
+    return (roof.children ?? []).flatMap((id) => {
+        const face = nodes[id];
+        const roofs = roofFaceOf(face);
+        if (!(face && roofs))
+            return [];
+        const corners = roofs.outline(face);
+        const heights = corners.map(([x, z]) => roofs.heightAt(face, x, z));
+        if (corners.length < 3 ||
+            !corners.every(([x, z]) => Number.isFinite(x) && Number.isFinite(z)) ||
+            !heights.every(Number.isFinite))
+            return [];
+        return [
+            {
+                id: face.id,
+                outline: corners.map(([x, z]) => [x0 + x * cos + z * sin, z0 - x * sin + z * cos]),
+                low: y0 + Math.min(...heights),
+                high: y0 + Math.max(...heights),
+            },
+        ];
+    });
+}
+/**
+ * A roof holds its segments and faces of other kinds (`capabilities.roofs`), nothing else: a child
+ * a write adds to it, of a registered kind that is neither, is refused. What it held before stays,
+ * so a roof saved before the rule still edits, and so does a kind this runtime has not registered
+ * (a plugin loaded elsewhere).
+ */
+export function validateRoofRelations(roof, nodes, before) {
+    if (roof.type !== 'roof')
+        return;
+    const prior = before?.[roof.id];
+    const held = new Set(prior?.type === 'roof' ? (prior.children ?? []) : []);
+    for (const id of roof.children ?? []) {
+        const child = nodes[id];
+        if (!child || held.has(id) || child.type === 'roof-segment')
+            continue;
+        const definition = nodeRegistry.get(child.type);
+        if (!definition || definition.capabilities.roofs)
+            continue;
+        throw new Error(`roof ${roof.id} holds its segments and faces of kinds that roof (capabilities.roofs): ${child.type} ${id} is neither.`);
+    }
+}

package/dist/registry/types.d.ts

@@ -1165,6 +1165,12 @@ export type NodeDefinition<S extends ZodObject<any>> = {
      * into the active building's plan coordinates below level architecture.
      */
     floorplanScope?: FloorplanScope;
+    /**
+     * Levels other than its own whose plans also draw this node: a stair that
+     * climbs to an upper floor shows on that floor's plan too. The plan builds
+     * it with `ctx.parent` set to the drawn level.
+     */
+    floorplanLinkedLevelIds?: (node: z.infer<S>) => readonly AnyNodeId[];
     /**
      * 2D drag affordances keyed by the string identifier emitted on
      * `endpoint-handle` (and similar interactive floor-plan primitives) via
@@ -1675,6 +1681,15 @@ export type Capabilities = {
         centerY?: number;
     };
     roofAccessory?: RoofAccessoryConfig;
+    /**
+     * The kind roofs: a node of it is one face of the roof that holds it (a plugin's solved roof
+     * plane), as a segment is one of the roof's masses. A roof lists it in `children` beside its
+     * segments and renders it through the kind's own renderer under the roof's transform, so hiding,
+     * selecting or deleting the roof takes its faces with it; the readers of a roof's extent and
+     * heights (the storey it covers, the walls it stands on, a view's frame) count it through
+     * `outline` and `heightAt`. See `RoofsCapability`.
+     */
+    roofs?: RoofsCapability;
     /**
      * Kind cuts a hole in the ceiling surface it is attached to (e.g. recessed
      * downlights). The viewer's `CeilingSystem` calls this for each child of a
@@ -2082,6 +2097,21 @@ export type RoofAccessoryConfig = {
      */
     dirtyHandledByOwnSystem?: boolean;
 };
+/**
+ * One face of the roof holding the node, in that roof's frame: metres, `[x, z]` in its plan and
+ * heights up from its origin. A roof standing unturned at its level's origin holds its faces in
+ * the level's frame.
+ */
+export type RoofsCapability = {
+    /** The face's outline in its roof's plan, corners in order. */
+    outline: (node: AnyNode) => readonly (readonly [x: number, z: number])[];
+    /**
+     * The height of the face's top surface over its roof's origin at a point of its outline. Readers
+     * take a face's lowest and highest points at the outline's corners, so a curved face gives an
+     * outline dense enough to hold them.
+     */
+    heightAt: (node: AnyNode, x: number, z: number) => number;
+};
 /**
  * Capability for kinds that cut a hole in their host ceiling when the node is
  * attached to a ceiling surface (e.g. recessed downlights). The viewer's