@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/floor-opening/definition.d.ts

@@ -1,3 +1,59 @@
-import { FloorOpeningNode, type NodeDefinition } from '@pascal-app/core';
-export declare const floorOpeningDefinition: NodeDefinition<typeof FloorOpeningNode>;
+export declare const floorOpeningDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`floor-opening_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"floor-opening">>;
+    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    hostZoneId: import("zod").ZodOptional<import("zod").ZodString>;
+    legacyPlateCuts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>>;
+    legacyCeilingCuts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>>;
+    source: import("zod").ZodDefault<import("zod").ZodString>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    surfaceId: import("zod").ZodOptional<import("zod").ZodString>;
+    drawnOn: import("zod").ZodDefault<import("zod").ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+    }>>;
+    cutsPrimary: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    cutsAdjacent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/floor-opening/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASxE,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CA0C1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGlC,CAAA"}

package/dist/floor-opening/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { FloorOpeningNode } from '@pascal-app/core';
+import type { NodeEditContribution } from '../definition-contributions.js';
+export declare const floorOpeningEditContribution: NodeEditContribution<typeof FloorOpeningNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/floor-opening/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AASvE,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAStF,CAAA"}

package/dist/floor-opening/definition.edit.js

@@ -0,0 +1,11 @@
+import { buildFloorOpeningFloorplan, floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan.js';
+export const floorOpeningEditContribution = {
+    // The void on the plan, and its corners while selected.
+    floorplan: buildFloorOpeningFloorplan,
+    floorplanAffordances: {
+        'move-vertex': floorOpeningMoveVertexAffordance,
+        'add-vertex': floorOpeningAddVertexAffordance,
+        'move-edge': floorOpeningMoveEdgeAffordance,
+        'delete-vertex': floorOpeningDeleteVertexAffordance,
+    },
+};

package/dist/floor-opening/definition.js

@@ -1,41 +1,4 @@
-import { FloorOpeningNode } from '@pascal-app/core';
-import { buildFloorOpeningFloorplan, floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan.js';
-export const floorOpeningDefinition = {
-    kind: 'floor-opening',
-    bake: 'strip',
-    schemaVersion: 1,
-    schema: FloorOpeningNode,
-    category: 'structure',
-    defaults: () => {
-        const { id: _id, type: _type, ...rest } = FloorOpeningNode.parse({
-            polygon: [
-                [0, 0],
-                [1, 0],
-                [1, 1],
-                [0, 1],
-            ],
-        });
-        return rest;
-    },
-    capabilities: {
-        duplicable: false,
-        deletable: true,
-        presettable: false,
-    },
-    dirtyTracking: false,
-    // The void on the plan, and its corners while selected.
-    floorplan: buildFloorOpeningFloorplan,
-    floorplanAffordances: {
-        'move-vertex': floorOpeningMoveVertexAffordance,
-        'add-vertex': floorOpeningAddVertexAffordance,
-        'move-edge': floorOpeningMoveEdgeAffordance,
-        'delete-vertex': floorOpeningDeleteVertexAffordance,
-    },
-    rendersChildren: false,
-    presentation: {
-        icon: { kind: 'iconify', name: 'lucide:square-dashed' },
-        label: 'Floor opening',
-        hidden: true,
-        actionMenu: false,
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { floorOpeningEditContribution } from './definition.edit.js';
+import { floorOpeningRenderDefinition } from './definition.render.js';
+export const floorOpeningDefinition = composeNodeDefinition(floorOpeningRenderDefinition, floorOpeningEditContribution);

package/dist/floor-opening/definition.render.d.ts

@@ -0,0 +1,6 @@
+import { FloorOpeningNode } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+export declare const floorOpeningRenderDefinition: NodeRenderDefinition<typeof FloorOpeningNode> & {
+    kind: 'floor-opening';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/floor-opening/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAAC,GAAG;IACzF,IAAI,EAAE,eAAe,CAAA;CAmCtB,CAAA"}

package/dist/floor-opening/definition.render.js

@@ -0,0 +1,32 @@
+import { FloorOpeningNode } from '@pascal-app/core';
+export const floorOpeningRenderDefinition = {
+    kind: 'floor-opening',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: FloorOpeningNode,
+    category: 'structure',
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = FloorOpeningNode.parse({
+            polygon: [
+                [0, 0],
+                [1, 0],
+                [1, 1],
+                [0, 1],
+            ],
+        });
+        return rest;
+    },
+    capabilities: {
+        duplicable: false,
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    rendersChildren: false,
+    presentation: {
+        icon: { kind: 'iconify', name: 'lucide:square-dashed' },
+        label: 'Floor opening',
+        hidden: true,
+        actionMenu: false,
+    },
+};

package/dist/floor-opening/floorplan.d.ts

@@ -1,11 +1,33 @@
-import type { FloorOpeningNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import { type FloorOpeningNode, type FloorplanAffordance, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+type Ring = [number, number][];
+/**
+ * A stair's opening: a box its stair cut, resized as a box. An elevator's opening keeps the free
+ * polygon handles: its cut comes from the car, so a drawn shape would not stick.
+ */
+export declare function isOwnedOpening(node: FloorOpeningNode): boolean;
+/**
+ * The square-cornered rectangle an owned opening is edited as: the ring itself when it already is
+ * one, otherwise (an opening cut with rounded corners before they were square) the box around it,
+ * aligned with its longest side.
+ */
+export declare function openingRectangle(polygon: ReadonlyArray<readonly [number, number]>): Ring;
+/**
+ * `rectangle` with corner `index` dragged to `point`: the opposite corner stays, the two sides
+ * through the dragged corner keep their directions, so the box stays a box.
+ */
+export declare function resizeRectangleCorner(rectangle: Ring, index: number, point: readonly [number, number]): Ring;
+/** `rectangle` with side `edgeIndex` moved parallel by `distance` along its outward normal. */
+export declare function moveRectangleEdge(rectangle: Ring, edgeIndex: number, distance: number): Ring;
 /**
  * A floor opening on the plan: a dashed amber outline (the void the surfaces
  * around it show), and — while selected — the same corner, midpoint and edge
- * handles slabs and zones use.
+ * handles slabs and zones use. A stair's opening is a box: its
+ * selected outline is solid, its sides carry a grip each to move them
+ * parallel and its corners resize it, all at a fixed screen size; it has no
+ * midpoint handles to add a vertex.
  */
 export declare function buildFloorOpeningFloorplan(node: FloorOpeningNode, ctx: GeometryContext): FloorplanGeometry | null;
-export declare const floorOpeningMoveVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningMoveVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -42,7 +64,7 @@ export declare const floorOpeningMoveVertexAffordance: import("@pascal-app/core"
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningAddVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningAddVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -79,7 +101,7 @@ export declare const floorOpeningAddVertexAffordance: import("@pascal-app/core")
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningMoveEdgeAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningMoveEdgeAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -116,7 +138,7 @@ export declare const floorOpeningMoveEdgeAffordance: import("@pascal-app/core").
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
-export declare const floorOpeningDeleteVertexAffordance: import("@pascal-app/core").FloorplanAffordance<{
+export declare const floorOpeningDeleteVertexAffordance: FloorplanAffordance<{
     object: "node";
     name?: string | undefined;
     parentId: string | null;
@@ -153,4 +175,5 @@ export declare const floorOpeningDeleteVertexAffordance: import("@pascal-app/cor
     cutsPrimary: boolean;
     cutsAdjacent: boolean;
 }>;
+export {};
 //# sourceMappingURL=floorplan.d.ts.map

package/dist/floor-opening/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/floor-opening/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAU5F;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAkD1B;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACqB,CAAA;AAClE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA;AACrE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA;AACpE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACyB,CAAA"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/floor-opening/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAExB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAazB,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;AAE9B;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CA0BxF;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,IAAI,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,IAAI,CAoBN;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgB5F;AA2DD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgE1B;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASuB,CAAA;AACpE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG3C,CAAA;AACD,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB2B,CAAA;AACtE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9C,CAAA"}

package/dist/floor-opening/floorplan.js

@@ -1,12 +1,142 @@
+import { authorStairOpeningPatches, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, snapPointToGrid, snapScalarToGrid } from '@pascal-app/editor';
 import { createPolygonAddVertexAffordance, createPolygonDeleteVertexAffordance, createPolygonMoveEdgeAffordance, createPolygonVertexAffordance, } from '../shared/polygon-vertex-affordance.js';
 const COLOR = '#f59e0b';
+/** A side of a stair opening never shrinks below this (metres). */
+const MIN_OPENING_SIDE = 0.2;
+/**
+ * A stair's opening: a box its stair cut, resized as a box. An elevator's opening keeps the free
+ * polygon handles: its cut comes from the car, so a drawn shape would not stick.
+ */
+export function isOwnedOpening(node) {
+    return node.source === 'stair' && !!node.ownerId;
+}
+/**
+ * The square-cornered rectangle an owned opening is edited as: the ring itself when it already is
+ * one, otherwise (an opening cut with rounded corners before they were square) the box around it,
+ * aligned with its longest side.
+ */
+export function openingRectangle(polygon) {
+    const ring = polygon.map(([x, z]) => [x, z]);
+    let longest = 0;
+    let axis = [1, 0];
+    for (const [i, a] of ring.entries()) {
+        const b = ring[(i + 1) % ring.length];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (length > longest) {
+            longest = length;
+            axis = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+        }
+    }
+    const normal = [-axis[1], axis[0]];
+    const along = ring.map(([x, z]) => x * axis[0] + z * axis[1]);
+    const across = ring.map(([x, z]) => x * normal[0] + z * normal[1]);
+    const [u0, u1, v0, v1] = [
+        Math.min(...along),
+        Math.max(...along),
+        Math.min(...across),
+        Math.max(...across),
+    ];
+    const at = (u, v) => [
+        u * axis[0] + v * normal[0],
+        u * axis[1] + v * normal[1],
+    ];
+    return [at(u0, v0), at(u1, v0), at(u1, v1), at(u0, v1)];
+}
+/**
+ * `rectangle` with corner `index` dragged to `point`: the opposite corner stays, the two sides
+ * through the dragged corner keep their directions, so the box stays a box.
+ */
+export function resizeRectangleCorner(rectangle, index, point) {
+    const at = (offset) => rectangle[(index + offset) % 4];
+    const origin = at(2);
+    const unit = (to) => {
+        const dx = to[0] - origin[0];
+        const dz = to[1] - origin[1];
+        const length = Math.hypot(dx, dz) || 1;
+        return [dx / length, dz / length];
+    };
+    const a = unit(at(1));
+    const b = unit(at(3));
+    const dx = point[0] - origin[0];
+    const dz = point[1] - origin[1];
+    const sideA = Math.max(MIN_OPENING_SIDE, dx * a[0] + dz * a[1]);
+    const sideB = Math.max(MIN_OPENING_SIDE, dx * b[0] + dz * b[1]);
+    const next = [...rectangle];
+    next[(index + 1) % 4] = [origin[0] + a[0] * sideA, origin[1] + a[1] * sideA];
+    next[(index + 3) % 4] = [origin[0] + b[0] * sideB, origin[1] + b[1] * sideB];
+    next[index] = [origin[0] + a[0] * sideA + b[0] * sideB, origin[1] + a[1] * sideA + b[1] * sideB];
+    return next;
+}
+/** `rectangle` with side `edgeIndex` moved parallel by `distance` along its outward normal. */
+export function moveRectangleEdge(rectangle, edgeIndex, distance) {
+    const start = rectangle[edgeIndex];
+    const end = rectangle[(edgeIndex + 1) % 4];
+    const opposite = rectangle[(edgeIndex + 2) % 4];
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+    let normal = [-(end[1] - start[1]) / length, (end[0] - start[0]) / length];
+    // Point the normal away from the box, whichever way the ring winds.
+    if ((opposite[0] - start[0]) * normal[0] + (opposite[1] - start[1]) * normal[1] > 0)
+        normal = [-normal[0], -normal[1]];
+    const depth = (opposite[0] - start[0]) * -normal[0] + (opposite[1] - start[1]) * -normal[1];
+    const travel = Math.max(MIN_OPENING_SIDE - depth, distance);
+    return rectangle.map((point, i) => i === edgeIndex || i === (edgeIndex + 1) % 4
+        ? [point[0] + normal[0] * travel, point[1] + normal[1] * travel]
+        : point);
+}
+/** Every write for `ring` on a stair's opening: its floor and ceiling cuts take it as drawn. */
+function ownedOpeningUpdates(id, ring) {
+    const authored = authorStairOpeningPatches(useScene.getState().nodes, id, ring);
+    return authored.length ? authored : [{ id, data: { polygon: ring } }];
+}
+function ownedOpeningSession(node, next) {
+    const rectangle = openingRectangle(node.polygon);
+    const affectedIds = [
+        ...new Set([
+            node.id,
+            ...authorStairOpeningPatches(useScene.getState().nodes, node.id, rectangle).map((patch) => patch.id),
+        ]),
+    ];
+    let ring = null;
+    // The drag previews through live overrides; the scene is written once, on release.
+    return {
+        affectedIds,
+        apply({ planPoint }) {
+            ring = next(rectangle, planPoint);
+            useLiveNodeOverrides
+                .getState()
+                .setMany(ownedOpeningUpdates(node.id, ring).map(({ id, data }) => [id, data]));
+        },
+        canCommit: () => ring !== null,
+        commit() {
+            const overrides = useLiveNodeOverrides.getState();
+            if (ring)
+                useScene.getState().updateNodes(ownedOpeningUpdates(node.id, ring));
+            for (const id of affectedIds)
+                overrides.clear(id);
+        },
+    };
+}
+/** Owned openings resize as a box; every other opening keeps the free polygon handles. */
+function ownedOr(owned, free) {
+    return { start: (args) => (isOwnedOpening(args.node) ? owned(args) : free.start(args)) };
+}
+const inert = (node) => ({
+    affectedIds: [node.id],
+    apply() { },
+    canCommit: () => false,
+});
 /**
  * A floor opening on the plan: a dashed amber outline (the void the surfaces
  * around it show), and — while selected — the same corner, midpoint and edge
- * handles slabs and zones use.
+ * handles slabs and zones use. A stair's opening is a box: its
+ * selected outline is solid, its sides carry a grip each to move them
+ * parallel and its corners resize it, all at a fixed screen size; it has no
+ * midpoint handles to add a vertex.
  */
 export function buildFloorOpeningFloorplan(node, ctx) {
-    const polygon = node.polygon;
+    const owned = isOwnedOpening(node);
+    const polygon = owned && ctx.viewState?.selected ? openingRectangle(node.polygon) : node.polygon;
     if (polygon.length < 3)
         return null;
     const selected = ctx.viewState?.selected ?? false;
@@ -18,9 +148,9 @@ export function buildFloorOpeningFloorplan(node, ctx) {
             fill: COLOR,
             fillOpacity: selected ? 0.22 : 0.1,
             stroke: COLOR,
-            strokeWidth: selected ? 0.04 : 0.03,
+            strokeWidth: selected ? (owned ? 0.06 : 0.04) : 0.03,
             strokeOpacity: 0.95,
-            strokeDasharray: '0.12 0.08',
+            ...(selected && owned ? {} : { strokeDasharray: '0.12 0.08' }),
         },
     ];
     if (selected) {
@@ -38,18 +168,29 @@ export function buildFloorOpeningFloorplan(node, ctx) {
         });
         polygon.forEach((a, i) => {
             const b = polygon[(i + 1) % polygon.length];
-            children.push({
-                kind: 'midpoint-handle',
-                point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
-                affordance: 'add-vertex',
-                payload: { edgeIndex: i },
-            });
+            const point = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            children.push(owned
+                ? {
+                    kind: 'endpoint-handle',
+                    point,
+                    state: 'idle',
+                    screenSized: true,
+                    affordance: 'move-edge',
+                    payload: { edgeIndex: i },
+                }
+                : {
+                    kind: 'midpoint-handle',
+                    point,
+                    affordance: 'add-vertex',
+                    payload: { edgeIndex: i },
+                });
         });
         polygon.forEach(([x, z], i) => {
             children.push({
                 kind: 'endpoint-handle',
                 point: [x, z],
                 state: 'idle',
+                ...(owned ? { screenSized: true } : {}),
                 affordance: 'move-vertex',
                 payload: { vertexIndex: i },
             });
@@ -57,7 +198,24 @@ export function buildFloorOpeningFloorplan(node, ctx) {
     }
     return { kind: 'group', children };
 }
-export const floorOpeningMoveVertexAffordance = createPolygonVertexAffordance('floor-opening');
-export const floorOpeningAddVertexAffordance = createPolygonAddVertexAffordance('floor-opening');
-export const floorOpeningMoveEdgeAffordance = createPolygonMoveEdgeAffordance('floor-opening');
-export const floorOpeningDeleteVertexAffordance = createPolygonDeleteVertexAffordance('floor-opening');
+export const floorOpeningMoveVertexAffordance = ownedOr(({ node, payload }) => {
+    const { vertexIndex } = payload;
+    return ownedOpeningSession(node, (rectangle, planPoint) => resizeRectangleCorner(rectangle, vertexIndex % 4, snapPointToGrid([planPoint[0], planPoint[1]], getSegmentGridStep())));
+}, createPolygonVertexAffordance('floor-opening'));
+export const floorOpeningAddVertexAffordance = ownedOr(({ node }) => inert(node), createPolygonAddVertexAffordance('floor-opening'));
+export const floorOpeningMoveEdgeAffordance = ownedOr(({ node, payload, initialPlanPoint }) => {
+    const { edgeIndex } = payload;
+    return ownedOpeningSession(node, (rectangle, planPoint) => {
+        const start = rectangle[edgeIndex % 4];
+        const end = rectangle[(edgeIndex + 1) % 4];
+        const opposite = rectangle[(edgeIndex + 2) % 4];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+        let normal = [-(end[1] - start[1]) / length, (end[0] - start[0]) / length];
+        if ((opposite[0] - start[0]) * normal[0] + (opposite[1] - start[1]) * normal[1] > 0)
+            normal = [-normal[0], -normal[1]];
+        const distance = snapScalarToGrid((planPoint[0] - initialPlanPoint[0]) * normal[0] +
+            (planPoint[1] - initialPlanPoint[1]) * normal[1], getSegmentGridStep());
+        return moveRectangleEdge(rectangle, edgeIndex % 4, distance);
+    });
+}, createPolygonMoveEdgeAffordance('floor-opening'));
+export const floorOpeningDeleteVertexAffordance = ownedOr(({ node }) => inert(node), createPolygonDeleteVertexAffordance('floor-opening'));

package/dist/guide/definition.d.ts

@@ -1,10 +1,66 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { GuideNode } from './schema.js';
-/**
- * Guide — Stage A. Measurement reference annotations placed by the
- * user (linear / area / arc). `GuideSystem` handles per-frame
- * positioning; the renderer mounts the visual marker + dimensioning
- * HUD via `<Html>`.
- */
-export declare const guideDefinition: NodeDefinition<typeof GuideNode>;
+export declare const guideDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`guide_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"guide">>;
+    url: import("zod").ZodString;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    scale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+    scaleReference: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodObject<{
+        start: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        end: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        realLengthMeters: import("zod").ZodNumber;
+        measuredLengthUnits: import("zod").ZodNumber;
+        metersPerUnit: import("zod").ZodNumber;
+        displayLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+        displayUnit: import("zod").ZodOptional<import("zod").ZodEnum<{
+            centimeters: "centimeters";
+            feet: "feet";
+            inches: "inches";
+            meters: "meters";
+        }>>;
+        label: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/guide/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/guide/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAiD5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/guide/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA"}

package/dist/guide/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { GuideNode } from './schema.js';
+export declare const guideEditContribution: NodeEditContribution<typeof GuideNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/guide/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/guide/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAExE,CAAA"}

package/dist/guide/definition.edit.js

@@ -0,0 +1,4 @@
+import { guideParametrics } from './parametrics.js';
+export const guideEditContribution = {
+    parametrics: guideParametrics,
+};

package/dist/guide/definition.js

@@ -1,53 +1,4 @@
-import { GuideNode as GuideNodeSchema } from '@pascal-app/core';
-import { guideParametrics } from './parametrics.js';
-import { GuideNode } from './schema.js';
-/**
- * Guide — Stage A. Measurement reference annotations placed by the
- * user (linear / area / arc). `GuideSystem` handles per-frame
- * positioning; the renderer mounts the visual marker + dimensioning
- * HUD via `<Html>`.
- */
-export const guideDefinition = {
-    kind: 'guide',
-    // Floorplan image reference: stripped from the bake, re-added live from
-    // scene_graph in the viewer (see plans → Part D; glb-reference-nodes.tsx).
-    bake: 'strip',
-    schemaVersion: 1,
-    schema: GuideNode,
-    category: 'site',
-    defaults: () => {
-        const stub = GuideNodeSchema.parse({ id: 'guide_default', type: 'guide' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        duplicable: false,
-        deletable: true,
-        // Guides are scene-specific measurement annotations — saving them
-        // as reusable catalog items has no meaning.
-        presettable: false,
-    },
-    parametrics: guideParametrics,
-    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
-    dirtyTracking: false,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 5,
-    },
-    presentation: {
-        label: 'Guide',
-        description: 'A measurement / reference annotation (linear, area, or arc).',
-        icon: { kind: 'url', src: '/icons/blueprint.webp' },
-        paletteSection: 'site',
-        paletteOrder: 30,
-    },
-    mcp: {
-        description: 'A measurement reference guide annotation.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { guideEditContribution } from './definition.edit.js';
+import { guideRenderDefinition } from './definition.render.js';
+export const guideDefinition = composeNodeDefinition(guideRenderDefinition, guideEditContribution);

package/dist/guide/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { GuideNode } from './schema.js';
+export declare const guideRenderDefinition: NodeRenderDefinition<typeof GuideNode> & {
+    kind: 'guide';
+};
+//# sourceMappingURL=definition.render.d.ts.map