@pascal-app/nodes 1.0.7 → 1.1.1

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/guide/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CA0C3F,CAAA"}

package/dist/guide/definition.render.js

@@ -0,0 +1,45 @@
+import { GuideNode as GuideNodeSchema } from '@pascal-app/core';
+import { GuideNode } from './schema.js';
+export const guideRenderDefinition = {
+    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,
+    },
+    // 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.',
+    },
+};

package/dist/gutter/definition.d.ts

@@ -1,19 +1,114 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { GutterNode } from './schema.js';
-/**
- * Gutter — a rain-water channel running along the eave of a roof
- * segment. Parented to a `roof-segment`; position is segment-local.
- *
- * Three-checkbox model — same shape as box-vent / ridge-vent: custom
- * `def.renderer` for the parent-segment transform lookup + live
- * override merge, pure geometry builder in `./geometry` shared with
- * the placement preview, no per-frame system (no animation, no
- * cross-kind cascades).
- *
- * Placement tool snaps to the eave line (segment-local
- * `Z = +depth/2, Y = wallHeight`) wherever the cursor lands on a
- * segment. After commit, the length L/R handles cover trimming and
- * the inspector covers profile + size adjustments.
- */
-export declare const gutterDefinition: NodeDefinition<typeof GutterNode>;
+export declare const gutterDefinition: 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<`gutter_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"gutter">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    materialPreset: import("zod").ZodDefault<import("zod").ZodString>;
+    roofSegmentId: import("zod").ZodOptional<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").ZodNumber>;
+    length: import("zod").ZodDefault<import("zod").ZodNumber>;
+    arc: import("zod").ZodOptional<import("zod").ZodObject<{
+        centerX: import("zod").ZodNumber;
+        centerZ: import("zod").ZodNumber;
+        radius: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    size: import("zod").ZodDefault<import("zod").ZodNumber>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    profile: import("zod").ZodDefault<import("zod").ZodEnum<{
+        box: "box";
+        "half-round": "half-round";
+        "k-style": "k-style";
+    }>>;
+    endCapLeft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    endCapRight: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    hangerStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        none: "none";
+        strap: "strap";
+    }>>;
+    hangerSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    outlets: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        offset: import("zod").ZodDefault<import("zod").ZodNumber>;
+        diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+        generatedBy: import("zod").ZodOptional<import("zod").ZodLiteral<"default-downspout">>;
+    }, import("zod/v4/core").$strip>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgE9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG5B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAuH1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAiB1E,CAAA"}

package/dist/gutter/definition.edit.js

@@ -0,0 +1,119 @@
+import { snapLengthToCorner } from './length-snap.js';
+import { gutterPaint } from './paint.js';
+import { gutterParametrics } from './parametrics.js';
+// Edge-to-arrow-center offset, matching the box-vent / ridge-vent
+// cadence so a roof's worth of accessories all read at the same scale.
+const SIDE_HANDLE_OFFSET = 0.2;
+// Gutter chevrons sit BELOW the gutter (the trough hangs below the
+// eave); the Y handle places its arrow under the cross-section apex.
+const SIZE_HANDLE_OFFSET = 0.15;
+// Minimums — well below the inspector defaults (2.0 m length, 0.13 m
+// profile) so users can shrink freely without locking.
+const MIN_LENGTH = 0.2;
+const MIN_SIZE = 0.05;
+// Centre of the gutter cross-section in vertical (Y) terms. The gutter
+// hangs from the eave (Y=0 in vent-mesh-local) down to Y=-size; chevrons
+// that want to read "beside the body" sit at -size/2.
+function getBodyMidY(n) {
+    return -Math.max(MIN_SIZE, n.size) / 2;
+}
+// Outward Z midpoint — the gutter's back wall sits at Z=0 and the rim
+// hangs out to Z≈+size (k-style) / +size (half-round / box). Side
+// handles place at Z=0 so they sit ABOVE the eave's fascia line.
+function getRimZ(n) {
+    return Math.max(MIN_SIZE, n.size) / 2;
+}
+// Length arrow on ±X (the eave direction). Asymmetric resize: drag one
+// end outward while the opposite end stays world-fixed by recentering
+// `position` along the gutter's own +X arm in segment frame. Same
+// yaw-aware projection as the box-vent / ridge-vent / chimney width
+// handles.
+//
+// Corner snap: when the dragged endpoint nears the geometric corner it
+// would form with another gutter (the crossing of their length axes),
+// `snapLengthToCorner` is the handle's magnetic snap, so Lines mode lands the
+// endpoint exactly on that corner, Grid mode uses the chosen step, and Off
+// leaves the cursor raw. Only this gutter's length changes.
+function gutterLengthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_LENGTH,
+        gridSnap: true,
+        currentValue: (n) => n.length,
+        magneticSnap: (initial, newLength, sceneApi) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
+            return snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi).length;
+        },
+        apply: (initial, newLength) => {
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
+            const newCenterX = anchorX + sign * (newLength / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newLength / 2) * armZ;
+            return {
+                length: newLength,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            position: (n) => [sign * (n.length / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), getRimZ(n)],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+// Profile-size arrow below the rim. axis='y', anchor='max' pins the
+// top of the trough (Y=0, the eave line) and grows the bottom edge
+// downward as the user drags toward -Y. Plain chevron — at typical
+// sizes (5″–6″) a dashed tracker would clutter the eave line.
+function gutterSizeHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        // 'max' = +Y edge anchored (top of the trough stays at Y=0); drag
+        // pulls the bottom edge further down. The base linear-resize
+        // factor for `max` is -1, which flips the cursor delta so dragging
+        // downward grows the value 1:1.
+        anchor: 'max',
+        min: MIN_SIZE,
+        gridSnap: true,
+        currentValue: (n) => n.size,
+        apply: (_n, newValue) => ({ size: Math.max(MIN_SIZE, newValue) }),
+        placement: {
+            // Sit at the bottom of the trough, pushed a bit further down so
+            // the chevron clears the rim and reads as a downward indicator.
+            position: (n) => [0, -Math.max(n.size, MIN_SIZE) - SIZE_HANDLE_OFFSET, getRimZ(n)],
+        },
+    };
+}
+const gutterHandles = [
+    gutterLengthHandle('right'),
+    gutterLengthHandle('left'),
+    gutterSizeHandle(),
+];
+export const gutterEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: gutterPaint,
+    },
+    parametrics: gutterParametrics,
+    handles: gutterHandles,
+    floorplanDependsOnSiblings: true,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place gutter on roof eave' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/gutter/definition.js

@@ -1,176 +1,4 @@
-import { GutterNode as GutterNodeSchema, gutterSlots, } from '@pascal-app/core';
-import { buildGutterFloorplan } from './floorplan.js';
-import { snapLengthToCorner } from './length-snap.js';
-import { gutterPaint } from './paint.js';
-import { gutterParametrics } from './parametrics.js';
-import { GutterNode } from './schema.js';
-// Edge-to-arrow-center offset, matching the box-vent / ridge-vent
-// cadence so a roof's worth of accessories all read at the same scale.
-const SIDE_HANDLE_OFFSET = 0.2;
-// Gutter chevrons sit BELOW the gutter (the trough hangs below the
-// eave); the Y handle places its arrow under the cross-section apex.
-const SIZE_HANDLE_OFFSET = 0.15;
-// Minimums — well below the inspector defaults (2.0 m length, 0.13 m
-// profile) so users can shrink freely without locking.
-const MIN_LENGTH = 0.2;
-const MIN_SIZE = 0.05;
-// Centre of the gutter cross-section in vertical (Y) terms. The gutter
-// hangs from the eave (Y=0 in vent-mesh-local) down to Y=-size; chevrons
-// that want to read "beside the body" sit at -size/2.
-function getBodyMidY(n) {
-    return -Math.max(MIN_SIZE, n.size) / 2;
-}
-// Outward Z midpoint — the gutter's back wall sits at Z=0 and the rim
-// hangs out to Z≈+size (k-style) / +size (half-round / box). Side
-// handles place at Z=0 so they sit ABOVE the eave's fascia line.
-function getRimZ(n) {
-    return Math.max(MIN_SIZE, n.size) / 2;
-}
-// Length arrow on ±X (the eave direction). Asymmetric resize: drag one
-// end outward while the opposite end stays world-fixed by recentering
-// `position` along the gutter's own +X arm in segment frame. Same
-// yaw-aware projection as the box-vent / ridge-vent / chimney width
-// handles.
-//
-// Corner snap: when the dragged endpoint nears the geometric corner it
-// would form with another gutter (the crossing of their length axes),
-// `snapLengthToCorner` is the handle's magnetic snap, so Lines mode lands the
-// endpoint exactly on that corner, Grid mode uses the chosen step, and Off
-// leaves the cursor raw. Only this gutter's length changes.
-function gutterLengthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_LENGTH,
-        gridSnap: true,
-        currentValue: (n) => n.length,
-        magneticSnap: (initial, newLength, sceneApi) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
-            return snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi).length;
-        },
-        apply: (initial, newLength) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
-            const newCenterX = anchorX + sign * (newLength / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newLength / 2) * armZ;
-            return {
-                length: newLength,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.length / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), getRimZ(n)],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Profile-size arrow below the rim. axis='y', anchor='max' pins the
-// top of the trough (Y=0, the eave line) and grows the bottom edge
-// downward as the user drags toward -Y. Plain chevron — at typical
-// sizes (5″–6″) a dashed tracker would clutter the eave line.
-function gutterSizeHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        // 'max' = +Y edge anchored (top of the trough stays at Y=0); drag
-        // pulls the bottom edge further down. The base linear-resize
-        // factor for `max` is -1, which flips the cursor delta so dragging
-        // downward grows the value 1:1.
-        anchor: 'max',
-        min: MIN_SIZE,
-        gridSnap: true,
-        currentValue: (n) => n.size,
-        apply: (_n, newValue) => ({ size: Math.max(MIN_SIZE, newValue) }),
-        placement: {
-            // Sit at the bottom of the trough, pushed a bit further down so
-            // the chevron clears the rim and reads as a downward indicator.
-            position: (n) => [0, -Math.max(n.size, MIN_SIZE) - SIZE_HANDLE_OFFSET, getRimZ(n)],
-        },
-    };
-}
-const gutterHandles = [
-    gutterLengthHandle('right'),
-    gutterLengthHandle('left'),
-    gutterSizeHandle(),
-];
-/**
- * Gutter — a rain-water channel running along the eave of a roof
- * segment. Parented to a `roof-segment`; position is segment-local.
- *
- * Three-checkbox model — same shape as box-vent / ridge-vent: custom
- * `def.renderer` for the parent-segment transform lookup + live
- * override merge, pure geometry builder in `./geometry` shared with
- * the placement preview, no per-frame system (no animation, no
- * cross-kind cascades).
- *
- * Placement tool snaps to the eave line (segment-local
- * `Z = +depth/2, Y = wallHeight`) wherever the cursor lands on a
- * segment. After commit, the length L/R handles cover trimming and
- * the inspector covers profile + size adjustments.
- */
-export const gutterDefinition = {
-    kind: 'gutter',
-    schemaVersion: 4,
-    schema: GutterNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    snapProfile: 'item',
-    defaults: () => {
-        const stub = GutterNodeSchema.parse({
-            id: 'gutter_default',
-            type: 'gutter',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: gutterSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: gutterPaint,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // eave fascia — no `buildCut`, just the dirty cascade so the
-        // parent roof's merged shell rebuilds when the gutter moves /
-        // resizes.
-        roofAccessory: {},
-    },
-    parametrics: gutterParametrics,
-    handles: gutterHandles,
-    floorplan: buildGutterFloorplan,
-    floorplanDependsOnSiblings: true,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place gutter on roof eave' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Gutter',
-        description: 'Rain-water channel running along the eave of a roof segment.',
-        icon: { kind: 'url', src: '/icons/gutter.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 122,
-    },
-    mcp: {
-        description: 'A gutter strip running along the eave of a roof segment. Three profiles (k-style ogee fascia, half-round, square box), length / size / thickness parametric.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { gutterEditContribution } from './definition.edit.js';
+import { gutterRenderDefinition } from './definition.render.js';
+export const gutterDefinition = composeNodeDefinition(gutterRenderDefinition, gutterEditContribution);

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

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

package/dist/gutter/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CA4C5F,CAAA"}

package/dist/gutter/definition.render.js

@@ -0,0 +1,46 @@
+import { GutterNode as GutterNodeSchema, gutterSlots } from '@pascal-app/core';
+import { buildGutterFloorplan } from './floorplan.js';
+import { GutterNode } from './schema.js';
+export const gutterRenderDefinition = {
+    kind: 'gutter',
+    schemaVersion: 4,
+    schema: GutterNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = GutterNodeSchema.parse({
+            id: 'gutter_default',
+            type: 'gutter',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: gutterSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // eave fascia — no `buildCut`, just the dirty cascade so the
+        // parent roof's merged shell rebuilds when the gutter moves /
+        // resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    floorplan: buildGutterFloorplan,
+    presentation: {
+        label: 'Gutter',
+        description: 'Rain-water channel running along the eave of a roof segment.',
+        icon: { kind: 'url', src: '/icons/gutter.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A gutter strip running along the eave of a roof segment. Three profiles (k-style ogee fascia, half-round, square box), length / size / thickness parametric.',
+    },
+};

package/dist/gutter/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/gutter/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAmOpE"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/gutter/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AA6BzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAoOpE"}