@pascal-app/nodes 1.0.7 → 1.1.1

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

@@ -0,0 +1,9 @@
+import { floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan-affordances.js';
+export const floorOpeningEditContribution = {
+    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;AAGvE,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAAC,GAAG;IACzF,IAAI,EAAE,eAAe,CAAA;CAqCtB,CAAA"}

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

@@ -0,0 +1,35 @@
+import { FloorOpeningNode } from '@pascal-app/core';
+import { buildFloorOpeningFloorplan } from './floorplan.js';
+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,
+    // The void on the plan, and its corners while selected.
+    floorplan: buildFloorOpeningFloorplan,
+    presentation: {
+        icon: { kind: 'iconify', name: 'lucide:square-dashed' },
+        label: 'Floor opening',
+        hidden: true,
+        actionMenu: false,
+    },
+};

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

@@ -0,0 +1,150 @@
+import { type FloorplanAffordance } from '@pascal-app/core';
+export declare const floorOpeningMoveVertexAffordance: FloorplanAffordance<{
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
+    hostZoneId?: string | undefined;
+    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
+    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
+    ownerId?: string | undefined;
+    surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
+}>;
+export declare const floorOpeningAddVertexAffordance: FloorplanAffordance<{
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
+    hostZoneId?: string | undefined;
+    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
+    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
+    ownerId?: string | undefined;
+    surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
+}>;
+export declare const floorOpeningMoveEdgeAffordance: FloorplanAffordance<{
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
+    hostZoneId?: string | undefined;
+    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
+    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
+    ownerId?: string | undefined;
+    surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
+}>;
+export declare const floorOpeningDeleteVertexAffordance: FloorplanAffordance<{
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `floor-opening_${string}`;
+    type: "floor-opening";
+    polygon: [number, number][];
+    hostZoneId?: string | undefined;
+    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
+    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
+    source: string;
+    ownerId?: string | undefined;
+    surfaceId?: string | undefined;
+    drawnOn: "ceiling" | "floor";
+    cutsPrimary: boolean;
+    cutsAdjacent: boolean;
+}>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/floor-opening/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAyEzB,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-affordances.js

@@ -0,0 +1,67 @@
+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';
+import { isOwnedOpening, moveRectangleEdge, openingRectangle, resizeRectangleCorner, } from './floorplan.js';
+/** 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,
+});
+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/floor-opening/floorplan.d.ts

@@ -1,5 +1,5 @@
-import { type FloorOpeningNode, type FloorplanAffordance, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
-type Ring = [number, number][];
+import type { FloorOpeningNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+export 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.
@@ -27,153 +27,4 @@ export declare function moveRectangleEdge(rectangle: Ring, edgeIndex: number, di
  * midpoint handles to add a vertex.
  */
 export declare function buildFloorOpeningFloorplan(node: FloorOpeningNode, ctx: GeometryContext): FloorplanGeometry | null;
-export declare const floorOpeningMoveVertexAffordance: FloorplanAffordance<{
-    object: "node";
-    name?: string | undefined;
-    parentId: string | null;
-    visible: boolean;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "orthographic" | "perspective";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
-    metadata: Record<string, unknown>;
-    provenance?: {
-        refs: {
-            ns?: string | undefined;
-            id: string;
-            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
-        }[];
-        lineage?: {
-            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
-            fromIds: string[];
-        } | undefined;
-    } | undefined;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    hostZoneId?: string | undefined;
-    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
-    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
-    source: string;
-    ownerId?: string | undefined;
-    surfaceId?: string | undefined;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-}>;
-export declare const floorOpeningAddVertexAffordance: FloorplanAffordance<{
-    object: "node";
-    name?: string | undefined;
-    parentId: string | null;
-    visible: boolean;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "orthographic" | "perspective";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
-    metadata: Record<string, unknown>;
-    provenance?: {
-        refs: {
-            ns?: string | undefined;
-            id: string;
-            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
-        }[];
-        lineage?: {
-            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
-            fromIds: string[];
-        } | undefined;
-    } | undefined;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    hostZoneId?: string | undefined;
-    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
-    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
-    source: string;
-    ownerId?: string | undefined;
-    surfaceId?: string | undefined;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-}>;
-export declare const floorOpeningMoveEdgeAffordance: FloorplanAffordance<{
-    object: "node";
-    name?: string | undefined;
-    parentId: string | null;
-    visible: boolean;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "orthographic" | "perspective";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
-    metadata: Record<string, unknown>;
-    provenance?: {
-        refs: {
-            ns?: string | undefined;
-            id: string;
-            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
-        }[];
-        lineage?: {
-            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
-            fromIds: string[];
-        } | undefined;
-    } | undefined;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    hostZoneId?: string | undefined;
-    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
-    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
-    source: string;
-    ownerId?: string | undefined;
-    surfaceId?: string | undefined;
-    drawnOn: "ceiling" | "floor";
-    cutsPrimary: boolean;
-    cutsAdjacent: boolean;
-}>;
-export declare const floorOpeningDeleteVertexAffordance: FloorplanAffordance<{
-    object: "node";
-    name?: string | undefined;
-    parentId: string | null;
-    visible: boolean;
-    camera?: {
-        position: [number, number, number];
-        target: [number, number, number];
-        mode: "orthographic" | "perspective";
-        fov?: number | undefined;
-        zoom?: number | undefined;
-    } | undefined;
-    metadata: Record<string, unknown>;
-    provenance?: {
-        refs: {
-            ns?: string | undefined;
-            id: string;
-            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
-        }[];
-        lineage?: {
-            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
-            fromIds: string[];
-        } | undefined;
-    } | undefined;
-    id: `floor-opening_${string}`;
-    type: "floor-opening";
-    polygon: [number, number][];
-    hostZoneId?: string | undefined;
-    legacyPlateCuts?: Record<string, [number, number][][]> | undefined;
-    legacyCeilingCuts?: Record<string, [number, number][][]> | undefined;
-    source: string;
-    ownerId?: string | undefined;
-    surfaceId?: string | undefined;
-    drawnOn: "ceiling" | "floor";
-    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,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"}
+{"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;AAM5F,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;AAErC;;;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;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgE1B"}

package/dist/floor-opening/floorplan.js

@@ -1,6 +1,3 @@
-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;
@@ -84,48 +81,6 @@ export function moveRectangleEdge(rectangle, edgeIndex, distance) {
         ? [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
@@ -198,24 +153,3 @@ export function buildFloorOpeningFloorplan(node, ctx) {
     }
     return { kind: 'group', children };
 }
-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