@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/dormer/definition.js

@@ -1,319 +1,4 @@
-import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
-import { buildDormerRoofCut } from './csg-geometry.js';
-import { buildDormerFloorplan } from './floorplan.js';
-import { dormerPaint } from './paint.js';
-import { dormerParametrics } from './parametrics.js';
-import { DormerNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.25;
-const HEIGHT_HANDLE_OFFSET = 0.25;
-const ROTATE_CORNER_OFFSET = 0.35;
-const ROTATE_RING_OFFSET = 0.08;
-// Schema/parametrics ranges — keep these aligned with `dormerParametrics`
-// so the in-world drag and the inspector slider clamp identically.
-const MIN_DIM = 0.5;
-const MIN_HEIGHT = 0;
-const MIN_ROOF_HEIGHT = 0;
-const MAX_ROOF_HEIGHT = 2;
-const MIN_SKIRT = 0.2;
-const MAX_SKIRT = 6;
-// Clamp used for handle Y placement so side chevrons stay reachable on
-// dormers whose wall is flat (`height ≈ 0`). The dormer body is
-// `height + roofHeight` tall; if that collapses too, the side arrows
-// would bury into the deck — this floor keeps them visible.
-const MIN_BODY_DISPLAY = 0.3;
-// Mid-Y of the dormer body in dormer-local frame. Y=0 is the eave
-// (where wall meets skirt); body extends up to `height + roofHeight`.
-// Side chevrons sit at the body midpoint so they read as "this is the
-// dormer's footprint" rather than floating at the apex or the eave.
-function getBodyMidY(n) {
-    return Math.max(n.height + n.roofHeight, MIN_BODY_DISPLAY) / 2;
-}
-// Width arrow on the +X (right) or -X (left) side. Asymmetric resize:
-// dragging one arrow grows the dormer outward from its own edge while
-// the opposite edge stays world-fixed in segment frame. The dormer's
-// registered ref frame is dormer-local (renderer applies position +
-// rotation on the registered group), so placements are in dormer-local
-// coords — no per-arrow rotation/translation compensation here.
-//
-// `apply` recomputes `position` so the anchored edge stays at the same
-// segment-local point even when the dormer is Y-rotated: project the
-// dormer's local +X onto segment frame via (cos r, -sin r), find the
-// anchored edge's segment-local XZ from the pre-drag node, then place
-// the new center half a new-width away from that anchor in the same
-// direction. Mirrors chimney + roof-segment width handle math.
-function dormerWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
-        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
-        anchor: side === 'right' ? 'min' : 'max',
-        // Default 'parent' portal (no `'grandparent'` escape). Arrows
-        // portal into the host roof segment's registered mesh, which lives
-        // inside the roof renderer's `<group name="segments-wrapper">`.
-        // That wrapper is `visible={false}` by default; `RoofEditSystem`
-        // imperatively flips it to `visible={true}` whenever any accessory
-        // hosted on a segment of this roof is selected, so the portaled
-        // arrows become visible during selection without us reaching for
-        // `portal: 'grandparent'` — which trips the same "Color target has
-        // no corresponding fragment stage output" WebGPU pipeline error
-        // chimney already documents.
-        min: MIN_DIM,
-        currentValue: (n) => n.width,
-        apply: (initial, newWidth) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
-            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
-            return {
-                width: newWidth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), 0],
-            // Flip the left chevron so it points outward toward -X. The
-            // generic LinearArrow only auto-orients for axis 'z'; +X / -X
-            // facing is up to the descriptor.
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Depth arrow on the +Z (front) or -Z (back) side. Asymmetric resize:
-// dragging one arrow grows the dormer outward from its own edge while
-// the opposite edge stays world-fixed in segment frame — same pattern
-// as `dormerWidthHandle`, just on the Z axis. `apply` recomputes
-// `position` so the anchored edge stays at the same segment-local point
-// even when the dormer is Y-rotated: project the dormer's local +Z onto
-// segment frame via (sin r, cos r), find the anchored edge's segment-
-// local XZ from the pre-drag node, then place the new center half a new-
-// depth away from that anchor in the same direction.
-function dormerDepthHandle(side) {
-    const sign = side === 'front' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'z',
-        // 'min' = -Z edge anchored (front arrow grows the +Z edge outward).
-        // 'max' = +Z edge anchored (back arrow grows the -Z edge outward).
-        anchor: side === 'front' ? 'min' : 'max',
-        min: MIN_DIM,
-        currentValue: (n) => n.depth,
-        apply: (initial, newDepth) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.sin(rotY);
-            const armZ = Math.cos(rotY);
-            const anchorX = initial.position[0] - sign * (initial.depth / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.depth / 2) * armZ;
-            const newCenterX = anchorX + sign * (newDepth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newDepth / 2) * armZ;
-            return {
-                depth: newDepth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [0, getBodyMidY(n), sign * (n.depth / 2 + SIDE_HANDLE_OFFSET)],
-            // The renderer auto-yaws axis-'z' chevrons by -π/2 so the default
-            // points +Z (front). Flip the back chevron 180° to point -Z.
-            rotationY: () => (side === 'front' ? 0 : Math.PI),
-        },
-    };
-}
-// Wall-height tracker — dashed vertical leader from the eave (y=0) up
-// to a draggable cube at the wall top (y=height), centred on the
-// footprint. Reads as "the dormer wall is THIS tall" without claiming
-// the roof apex. Same `linear-resize axis='y'` pipeline as every other
-// height handle; `shape: 'tracker'` only swaps the visual.
-function dormerWallHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        min: MIN_HEIGHT,
-        currentValue: (n) => n.height,
-        apply: (_n, newValue) => ({ height: newValue }),
-        placement: {
-            position: (n) => [0, Math.max(n.height, 0.001), 0],
-        },
-        trackerBaseY: () => 0,
-    };
-}
-// Wall-skirt chevron — sits BELOW the eave, at the bottom of the
-// hung-wall skirt that extends down into the host roof. Drag pulls the
-// skirt's bottom edge further down (or up) to grow / shrink
-// `wallSkirtHeight`. Anchor 'max' keeps the eave (y=0) fixed; the
-// linear-resize factor (-1 for anchor 'max') flips the drag sign so
-// dragging the chevron downward increases the value 1:1.
-//
-// Plain arrow (not tracker) because tracker only renders an upward
-// leader; the dashed line would point the wrong way for a downward
-// span. The auto-orient logic in `ArrowHandle` flips the chevron to
-// point -Y when placement.y < 0, so the arrow visibly points down.
-function dormerWallSkirtHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'max',
-        min: MIN_SKIRT,
-        max: MAX_SKIRT,
-        currentValue: (n) => n.wallSkirtHeight,
-        apply: (_n, newValue) => ({ wallSkirtHeight: newValue }),
-        placement: {
-            position: (n) => [0, -(n.wallSkirtHeight + HEIGHT_HANDLE_OFFSET), 0],
-        },
-    };
-}
-// Roof-height chevron at the dormer's peak. Drag adjusts `roofHeight`
-// directly — unlike roof-segment there's no pitch back-solve because
-// dormer stores roof height as a literal scalar, not a pitch angle.
-// Placed slightly above the apex (height + roofHeight) so the chevron
-// visually attaches to the ridge.
-function dormerRoofHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_ROOF_HEIGHT,
-        max: MAX_ROOF_HEIGHT,
-        currentValue: (n) => n.roofHeight,
-        apply: (_n, newValue) => ({ roofHeight: newValue }),
-        placement: {
-            position: (n) => [0, n.height + n.roofHeight + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-// Whole-dormer rotation gizmo at the +X / +Z corner of the footprint,
-// guide ring traces the corner-diagonal radius on hover / drag.
-// Dormer-local frame is the registered group (renderer applies
-// node.position + node.rotation there), so the default rotation pivot
-// (rideObject origin = dormer center) is correct — no
-// `rotationCenter` override needed.
-function dormerRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        // Negate the cursor delta to match three.js Y-rotation handedness
-        // (cursor atan2 ticks opposite-handed from `rotation-y`).
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: (n) => {
-                const halfX = n.width / 2 + ROTATE_CORNER_OFFSET;
-                const halfZ = n.depth / 2 + ROTATE_CORNER_OFFSET;
-                return [halfX, getBodyMidY(n), halfZ];
-            },
-            // The two-headed icon's natural bias points along +X; aim it at
-            // the corner (45° outward from the dormer's local frame).
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => Math.hypot(n.width / 2, n.depth / 2) + ROTATE_RING_OFFSET,
-            y: (n) => getBodyMidY(n),
-        },
-    };
-}
-const dormerHandles = [
-    dormerWidthHandle('right'),
-    dormerWidthHandle('left'),
-    dormerDepthHandle('front'),
-    dormerDepthHandle('back'),
-    dormerWallHeightHandle(),
-    dormerRotateHandle(),
-    // The wall-skirt (downward chevron), roof-height (peak chevron), and
-    // the asymmetric front/back depth split stay out for now. Re-adding
-    // any of them previously fired the "Color target has no
-    // corresponding fragment stage output" WebGPU pipeline error chimney
-    // already documented for its flue / cap-thickness / cap-overhang
-    // extras — only reproducible while `portal: 'grandparent'` was set,
-    // which we no longer rely on (RoofEditSystem reveals the wrapper
-    // instead). The shapes themselves are valid; if the count budget
-    // turns out to also be sensitive without grandparent portal, keep
-    // the current compact set.
-    // dormerWallSkirtHandle(),
-    // dormerRoofHeightHandle(),
-];
-/**
- * Dormer — a small house-shaped protrusion sitting on top of a roof
- * segment. Windows are hosted child nodes; the legacy window* fields remain
- * in the schema only so scene migration can preserve older dormers.
- *
- * The renderer cuts each hosted window from the dormer shell and mounts
- * the regular WindowNode renderer in the selected wall-face frame.
- */
-export const dormerDefinition = {
-    kind: 'dormer',
-    schemaVersion: 4,
-    schema: DormerNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        // Zod fills in id/type via their .default() factories; we strip
-        // both so the returned shape is a partial template a consumer can
-        // spread into createNode() with a fresh id.
-        const stub = DormerNodeSchema.parse({});
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        // Dormers own their WindowNode children. Duplicate the complete subtree
-        // so the copied dormer never aliases windows from the source dormer.
-        duplicable: { subtree: true },
-        deletable: true,
-        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
-        // cascade to the host segment's parent roof so its merged shell
-        // re-CSGs with the new cut. `buildCut` returns the segment-local
-        // geometry the merge loop subtracts from shin / deck / wall.
-        roofAccessory: {
-            buildCut: (node, _hostSegment) => buildDormerRoofCut(node),
-        },
-        // Paint dispatch for the wall / side / top surface split. The
-        // editor's selection-manager routes paint hover / click /
-        // preview through this entry rather than carrying a kind-name
-        // arm.
-        paint: dormerPaint,
-    },
-    relations: {
-        hosts: ['window'],
-        cascadeDelete: 'descendants',
-    },
-    affordanceTools: {
-        // Drag-to-place tool for duplicate + move. Reuses the placement
-        // ghost preview but seeds it from the moving (cloned) node so the
-        // duplicate keeps the source's dimensions, materials, and window
-        // options.
-        move: () => import('./move-tool.js'),
-    },
-    parametrics: dormerParametrics,
-    handles: dormerHandles,
-    floorplan: buildDormerFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place dormer on roof' },
-        { key: 'R / Shift+R', label: 'Rotate ghost ±15°' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Dormer',
-        description: 'House-shaped protrusion on a roof segment.',
-        icon: { kind: 'url', src: '/icons/dormer.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 125,
-    },
-    mcp: {
-        description: 'A dormer on a roof segment. Its windows are hosted WindowNode children.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { dormerEditContribution } from './definition.edit.js';
+import { dormerRenderDefinition } from './definition.render.js';
+export const dormerDefinition = composeNodeDefinition(dormerRenderDefinition, dormerEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.render.ts"],"names":[],"mappings":"AAKA,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;CAkD5F,CAAA"}

package/dist/dormer/definition.render.js

@@ -0,0 +1,52 @@
+import { DormerNode as DormerNodeSchema, } from '@pascal-app/core';
+import { buildDormerRoofCut } from './csg-geometry.js';
+import { DormerNode } from './schema.js';
+export const dormerRenderDefinition = {
+    kind: 'dormer',
+    schemaVersion: 4,
+    schema: DormerNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        // Zod fills in id/type via their .default() factories; we strip
+        // both so the returned shape is a partial template a consumer can
+        // spread into createNode() with a fresh id.
+        const stub = DormerNodeSchema.parse({});
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        // Dormers own their WindowNode children. Duplicate the complete subtree
+        // so the copied dormer never aliases windows from the source dormer.
+        duplicable: { subtree: true },
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Dirty marks
+        // cascade to the host segment's parent roof so its merged shell
+        // re-CSGs with the new cut. `buildCut` returns the segment-local
+        // geometry the merge loop subtracts from shin / deck / wall.
+        roofAccessory: {
+            buildCut: (node, _hostSegment) => buildDormerRoofCut(node),
+        },
+    },
+    relations: {
+        hosts: ['window'],
+        cascadeDelete: 'descendants',
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Dormer',
+        description: 'House-shaped protrusion on a roof segment.',
+        icon: { kind: 'url', src: '/icons/dormer.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 125,
+    },
+    mcp: {
+        description: 'A dormer on a roof segment. Its windows are hosted WindowNode children.',
+    },
+};

package/dist/downspout/definition.d.ts

@@ -1,17 +1,109 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { DownspoutNode } from './schema.js';
-/**
- * Downspout — vertical drop pipe taking water from a gutter outlet to
- * the ground. Scene-graph parent is the same roof-segment the host
- * gutter sits on (so it renders under `roof-elements` like every
- * other accessory); the logical link to the gutter is via the
- * `gutterId` field, which the renderer uses to look up the outlet
- * position.
- *
- * No `handles` yet — the downspout's geometry is anchored to the
- * gutter's outlet. Length (tracker cube at the routed mouth) and
- * diameter (chevron on the wall run) are draggable arrows; the wall
- * standoff lives in the inspector.
- */
-export declare const downspoutDefinition: NodeDefinition<typeof DownspoutNode>;
+export declare const downspoutDefinition: 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<`downspout_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"downspout">>;
+    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>;
+    gutterId: import("zod").ZodOptional<import("zod").ZodString>;
+    outletId: import("zod").ZodOptional<import("zod").ZodString>;
+    length: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lengthMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+        manual: "manual";
+        "to-ground": "to-ground";
+    }>>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    standoff: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        auto: "auto";
+        rect: "rect";
+        round: "round";
+    }>>;
+    strapStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        band: "band";
+        none: "none";
+    }>>;
+    strapSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    terminal: import("zod").ZodDefault<import("zod").ZodEnum<{
+        kickout: "kickout";
+        splash: "splash";
+        straight: "straight";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAiIxC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,CA8DpE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG/B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.edit.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AASvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAqI7C,eAAO,MAAM,yBAAyB,EAAE,oBAAoB,CAAC,OAAO,aAAa,CAchF,CAAA"}

package/dist/downspout/definition.edit.js

@@ -0,0 +1,134 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint.js';
+import { downspoutParametrics } from './parametrics.js';
+import { computeDownspoutPath, downspoutPipeDims, effectiveWallJog, resolveDownspoutRouting, } from './routing.js';
+// Mirrors the parametric `min`s so handle drags can't shrink the pipe
+// past what the inspector would accept.
+const MIN_LENGTH = 0.1;
+// The length cube + dashed leader ride the straight WALL RUN, offset
+// outward (+Z, over the eave) past the pipe surface so they float clear
+// of the pipe instead of touching it.
+const LENGTH_HANDLE_PAD = 0.12;
+// Lift the length cube a little up the run from the very bottom so it
+// reads as a height grip rather than sitting at the pipe's end. Clamped
+// to the run top so it never climbs above the straight section.
+const CUBE_LIFT = 0.18;
+// Side-move arrows: how far ±X (along the eave) they sit from the pipe,
+// and how far below the gutter floor — near the top so they read as
+// "grab and slide along the eave".
+const SIDE_MOVE_OFFSET = 0.22;
+const SIDE_MOVE_Y = -0.12;
+/**
+ * Length tracker — a dashed vertical leader from the outlet (Y = 0,
+ * the gutter floor) down to a small cube near the bottom of the
+ * straight wall run, `anchor: 'max'` + `axis: 'y'` so dragging the
+ * cube down extends the pipe 1:1.
+ *
+ * Both the cube and the leader sit on the wall-run line but offset
+ * outward (away from the pipe) by `radius + LENGTH_HANDLE_PAD`, so the
+ * whole dimension floats clear of the pipe — it reads as "change the
+ * height" rather than a box jammed onto the kicked-out mouth. The cube
+ * rides the run BOTTOM (above the kickout), not the mouth, so the
+ * dimension stays on the straight part.
+ */
+function downspoutLengthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'max',
+        shape: 'tracker',
+        min: MIN_LENGTH,
+        gridSnap: true,
+        currentValue: (n) => n.length,
+        apply: (_n, newValue) => ({
+            length: Math.max(MIN_LENGTH, newValue),
+            lengthMode: 'manual',
+        }),
+        placement: {
+            position: (n, scene) => {
+                const routing = resolveDownspoutRouting(n, scene);
+                const path = computeDownspoutPath(n.length, effectiveWallJog(n, routing), (n.terminal ?? 'splash') !== 'straight');
+                const halfZ = downspoutPipeDims(n, routing).halfZ;
+                const y = Math.min(path.wallRunTopY, path.wallRunBottomY + CUBE_LIFT);
+                return [0, y, path.wallRunZ + halfZ + LENGTH_HANDLE_PAD];
+            },
+        },
+        // Leader starts at Y = 0 (outlet / gutter floor) and runs DOWN past
+        // the cube — same tracker the wall / chimney height fields use.
+        trackerBaseY: () => 0,
+    };
+}
+// Usable half-span — keep the outlet a hair inside each end so the
+// collar never lands on a cap (the geometry clamps too; this bounds the
+// drag). Reads the host gutter's length.
+function moveBound(n, gutter) {
+    return Math.max(0.05, Math.max(0.05, gutter?.length ?? 2) / 2 - 0.1);
+}
+// Effective outlet offset for `currentValue` — reads the gutter's live
+// override first (so the dragged value tracks) then the store.
+function readOutletOffset(n) {
+    if (!n.gutterId)
+        return 0;
+    const id = n.gutterId;
+    const override = useLiveNodeOverrides.getState().get(id);
+    const gutter = useScene.getState().nodes[id];
+    const outlets = override?.outlets ?? gutter?.outlets ?? [];
+    return outlets.find((o) => o.id === n.outletId)?.offset ?? 0;
+}
+/**
+ * Side-move arrow — one of a ±X pair that slides the downspout along the
+ * eave. The position lives on the host gutter's outlet
+ * (`gutter.outlets[].offset`), not on the downspout, so `overrideTarget`
+ * redirects the drag's live override + commit to the gutter and `apply`
+ * returns the gutter's patch. The arrows sit near the top of the pipe
+ * and ride its group, which moves with the outlet — so they track the
+ * cursor 1:1 (`anchor: 'min'` → factor +1).
+ */
+function downspoutMoveHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'min',
+        cursor: 'ew-resize',
+        gridSnap: true,
+        overrideTarget: (n) => (n.gutterId ? n.gutterId : undefined),
+        currentValue: (n) => readOutletOffset(n),
+        apply: (n, newOffset, scene) => {
+            const gutter = n.gutterId ? scene.get(n.gutterId) : undefined;
+            if (!gutter)
+                return {};
+            const outlets = (gutter.outlets ?? []).map((o) => o.id === n.outletId ? { ...o, offset: newOffset, generatedBy: undefined } : o);
+            // Patch targets the GUTTER (overrideTarget), not the downspout.
+            return { outlets };
+        },
+        min: (n, scene) => -moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
+        max: (n, scene) => moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
+        placement: {
+            // Static ±X beside the top of the pipe; the group it rides moves
+            // with the outlet, so the arrow stays under the cursor as it slides.
+            position: () => [sign * SIDE_MOVE_OFFSET, SIDE_MOVE_Y, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+    };
+}
+const downspoutHandles = [
+    downspoutLengthHandle(),
+    downspoutMoveHandle('left'),
+    downspoutMoveHandle('right'),
+];
+export const downspoutEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: { ...surfacePaintCapability, materialTarget: 'downspout' },
+    },
+    parametrics: downspoutParametrics,
+    handles: downspoutHandles,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Hover gutter', label: 'Highlight outlet' },
+        { key: 'Left click', label: 'Drop downspout from outlet' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};