@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/structural-grid/definition.js

@@ -1,51 +1,4 @@
-import { buildStructuralGridFloorplan } from './floorplan.js';
-import { StructuralGridNode } from './schema.js';
-export const structuralGridDefinition = {
-    kind: 'structural-grid',
-    bake: 'strip',
-    schemaVersion: 1,
-    schema: StructuralGridNode,
-    category: 'structure',
-    extensions: {
-        'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool.js'),
-            availableModes: ['expert'],
-            preferredView: '2d',
-        },
-    },
-    snapProfile: 'structural',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        start: [0, 0],
-        end: [0, 5],
-        label: '1',
-        showStartBubble: true,
-        showEndBubble: true,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        deletable: true,
-        presettable: false,
-    },
-    dirtyTracking: false,
-    floorplan: buildStructuralGridFloorplan,
-    toolHints: [
-        { key: 'Left click', label: 'Start grid axis' },
-        { key: 'Left click', label: 'Finish grid axis' },
-        { key: 'Alt', label: 'Bypass snapping' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Structural Grid',
-        description: 'Persistent construction grid axis with identification bubbles.',
-        icon: { kind: 'url', src: '/icons/structural-grid.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 72,
-    },
-    mcp: {
-        description: 'A floor-plan structural datum axis defined by two level-local points and a grid identifier.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { structuralGridEditContribution } from './definition.edit.js';
+import { structuralGridRenderDefinition } from './definition.render.js';
+export const structuralGridDefinition = composeNodeDefinition(structuralGridRenderDefinition, structuralGridEditContribution);

package/dist/structural-grid/definition.render.d.ts

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

package/dist/structural-grid/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,8BAA8B,EAAE,oBAAoB,CAAC,OAAO,kBAAkB,CAAC,GAAG;IAC7F,IAAI,EAAE,iBAAiB,CAAA;CAmCxB,CAAA"}

package/dist/structural-grid/definition.render.js

@@ -0,0 +1,35 @@
+import { StructuralGridNode } from './schema.js';
+export const structuralGridRenderDefinition = {
+    kind: 'structural-grid',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: StructuralGridNode,
+    category: 'structure',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        start: [0, 0],
+        end: [0, 5],
+        label: '1',
+        showStartBubble: true,
+        showEndBubble: true,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    presentation: {
+        label: 'Structural Grid',
+        description: 'Persistent construction grid axis with identification bubbles.',
+        icon: { kind: 'url', src: '/icons/structural-grid.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A floor-plan structural datum axis defined by two level-local points and a grid identifier.',
+    },
+};

package/dist/turbine-vent/definition.d.ts

@@ -1,24 +1,98 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { TurbineVentNode } from './schema.js';
-/**
- * Turbine vent (whirlybird) — a wind-driven spinning exhaust vent that
- * sits on a roof slope. Parented to a `roof-segment`; position is
- * segment-local; rotation rotates the vent around the segment's vertical
- * axis after the slope tilt is applied.
- *
- * Composition (three-checkbox model):
- *  - **`renderer` (custom)** — like the box vent, the turbine needs the
- *    parent segment's transform + slope to position itself, which the
- *    registry-era roof-segment renderer doesn't auto-nest. The custom
- *    renderer reads the segment from `useScene`, applies the transform
- *    stack, and — uniquely among vents — drives the head's idle spin via
- *    `useFrame`. The spin lives in the renderer (not a `def.system`)
- *    because it's purely cosmetic: no cross-node cascade, no shared
- *    animation state, and it must not perturb the handle frame.
- *  - **no `geometry`** — geometry is created inside the renderer via the
- *    shared pure builders in `./geometry` (split base / head so the head
- *    can spin independently), matching box-vent's mount semantics.
- *  - **no `system`** — see above; the spin is renderer-local.
- */
-export declare const turbineVentDefinition: NodeDefinition<typeof TurbineVentNode>;
+export declare const turbineVentDefinition: 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<`tvent_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"turbine-vent">>;
+    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>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    neckHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    vaneCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    spinSpeed: import("zod").ZodDefault<import("zod").ZodNumber>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        cylinder: "cylinder";
+        globe: "globe";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/turbine-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoD1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA0DxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

package/dist/turbine-vent/definition.edit.d.ts

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

package/dist/turbine-vent/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAuD/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAiBpF,CAAA"}

package/dist/turbine-vent/definition.edit.js

@@ -0,0 +1,66 @@
+import { buildTurbineVentFloorplan } from './floorplan.js';
+import { turbineVentPaint } from './paint.js';
+import { turbineVentParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.25;
+const HEIGHT_HANDLE_OFFSET = 0.2;
+const MIN_DIM = 0.12;
+const MIN_HEIGHT = 0.12;
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Diameter arrow on the +X side. The turbine is radially symmetric, so a
+// single symmetric chevron (anchor 'center') grows the whole head from
+// the centre — no left/right asymmetry to preserve.
+function turbineVentDiameterHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.diameter,
+        apply: (_n, newValue) => ({ diameter: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [n.diameter / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+// Height arrow above the top. anchor='min' pins the flange base to the
+// slope at vent-local y=0 and the top follows the pointer.
+function turbineVentHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+// `portal: 'grandparent'` on every handle — see box-vent's note. The vent
+// rides the roof→segment→node frame chain, so the handle rig must too, or
+// the handles render offset from the vent.
+const turbineVentHandles = [
+    turbineVentDiameterHandle(),
+    turbineVentHeightHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+export const turbineVentEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: turbineVentPaint,
+    },
+    parametrics: turbineVentParametrics,
+    handles: turbineVentHandles,
+    floorplan: buildTurbineVentFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place turbine vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/turbine-vent/definition.js

@@ -1,121 +1,4 @@
-import { TurbineVentNode as TurbineVentNodeSchema, turbineVentSlots, } from '@pascal-app/core';
-import { buildTurbineVentFloorplan } from './floorplan.js';
-import { turbineVentPaint } from './paint.js';
-import { turbineVentParametrics } from './parametrics.js';
-import { TurbineVentNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.25;
-const HEIGHT_HANDLE_OFFSET = 0.2;
-const MIN_DIM = 0.12;
-const MIN_HEIGHT = 0.12;
-function getBodyMidY(n) {
-    return Math.max(0.001, n.height) / 2;
-}
-// Diameter arrow on the +X side. The turbine is radially symmetric, so a
-// single symmetric chevron (anchor 'center') grows the whole head from
-// the centre — no left/right asymmetry to preserve.
-function turbineVentDiameterHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_DIM,
-        currentValue: (n) => n.diameter,
-        apply: (_n, newValue) => ({ diameter: Math.max(MIN_DIM, newValue) }),
-        placement: {
-            position: (n) => [n.diameter / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
-        },
-    };
-}
-// Height arrow above the top. anchor='min' pins the flange base to the
-// slope at vent-local y=0 and the top follows the pointer.
-function turbineVentHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_HEIGHT,
-        currentValue: (n) => n.height,
-        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
-        placement: {
-            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-// `portal: 'grandparent'` on every handle — see box-vent's note. The vent
-// rides the roof→segment→node frame chain, so the handle rig must too, or
-// the handles render offset from the vent.
-const turbineVentHandles = [
-    turbineVentDiameterHandle(),
-    turbineVentHeightHandle(),
-].map((h) => ({ ...h, portal: 'grandparent' }));
-/**
- * Turbine vent (whirlybird) — a wind-driven spinning exhaust vent that
- * sits on a roof slope. Parented to a `roof-segment`; position is
- * segment-local; rotation rotates the vent around the segment's vertical
- * axis after the slope tilt is applied.
- *
- * Composition (three-checkbox model):
- *  - **`renderer` (custom)** — like the box vent, the turbine needs the
- *    parent segment's transform + slope to position itself, which the
- *    registry-era roof-segment renderer doesn't auto-nest. The custom
- *    renderer reads the segment from `useScene`, applies the transform
- *    stack, and — uniquely among vents — drives the head's idle spin via
- *    `useFrame`. The spin lives in the renderer (not a `def.system`)
- *    because it's purely cosmetic: no cross-node cascade, no shared
- *    animation state, and it must not perturb the handle frame.
- *  - **no `geometry`** — geometry is created inside the renderer via the
- *    shared pure builders in `./geometry` (split base / head so the head
- *    can spin independently), matching box-vent's mount semantics.
- *  - **no `system`** — see above; the spin is renderer-local.
- */
-export const turbineVentDefinition = {
-    kind: 'turbine-vent',
-    schemaVersion: 3,
-    schema: TurbineVentNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        const stub = TurbineVentNodeSchema.parse({ id: 'tvent_default', type: 'turbine-vent' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: turbineVentSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: turbineVentPaint,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // slope — no `buildCut`, just the dirty cascade so the parent roof's
-        // merged shell rebuilds when the vent moves / resizes.
-        roofAccessory: {},
-    },
-    parametrics: turbineVentParametrics,
-    handles: turbineVentHandles,
-    floorplan: buildTurbineVentFloorplan,
-    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 turbine vent on roof' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Turbine Vent',
-        description: 'Wind-driven spinning whirlybird exhaust vent for a roof slope.',
-        icon: { kind: 'url', src: '/icons/turbine-vent.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 121,
-    },
-    mcp: {
-        description: 'A spinning turbine (whirlybird) vent on a roof segment. Style: globe / cylinder. Parametric diameter/height/neckHeight/vaneCount and idle spinSpeed.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { turbineVentEditContribution } from './definition.edit.js';
+import { turbineVentRenderDefinition } from './definition.render.js';
+export const turbineVentDefinition = composeNodeDefinition(turbineVentRenderDefinition, turbineVentEditContribution);

package/dist/turbine-vent/definition.render.d.ts

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

package/dist/turbine-vent/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CAuCrB,CAAA"}

package/dist/turbine-vent/definition.render.js

@@ -0,0 +1,40 @@
+import { TurbineVentNode as TurbineVentNodeSchema, turbineVentSlots } from '@pascal-app/core';
+import { TurbineVentNode } from './schema.js';
+export const turbineVentRenderDefinition = {
+    kind: 'turbine-vent',
+    schemaVersion: 3,
+    schema: TurbineVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = TurbineVentNodeSchema.parse({ id: 'tvent_default', type: 'turbine-vent' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: turbineVentSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // slope — no `buildCut`, just the dirty cascade so the parent roof's
+        // merged shell rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Turbine Vent',
+        description: 'Wind-driven spinning whirlybird exhaust vent for a roof slope.',
+        icon: { kind: 'url', src: '/icons/turbine-vent.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 121,
+    },
+    mcp: {
+        description: 'A spinning turbine (whirlybird) vent on a roof segment. Style: globe / cylinder. Parametric diameter/height/neckHeight/vaneCount and idle spinSpeed.',
+    },
+};

package/dist/turbine-vent/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,sCAwN9E"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,sCAyN9E"}

package/dist/turbine-vent/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -55,9 +55,9 @@ export default function MoveTurbineVentTool({ node }) {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const updatePreview = (event) => {
@@ -69,7 +69,8 @@ export default function MoveTurbineVentTool({ node }) {
             lastTarget = target;
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true &&
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
                 (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnap = [sx, sz];
@@ -122,7 +123,7 @@ export default function MoveTurbineVentTool({ node }) {
                 position: [target.localX, target.localY, target.localZ],
                 rotation: original.rotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             useScene.temporal.getState().pause();
             st.dirtyNodes.add(targetSegmentId);

package/dist/unit/definition.d.ts

@@ -1,10 +1,54 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { UnitNode } from './schema.js';
-/**
- * Unit — a referencing overlay, not a container. It lists member zone ids
- * and owns no geometry: member zones carry its tint, and the site panel
- * drives selection (declaring `selectable` would subscribe the kind to 3D
- * clicks that have nothing to hit). Not placeable: no tool, no palette tile.
- */
-export declare const unitDefinition: NodeDefinition<typeof UnitNode>;
+export declare const unitDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    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>>;
+    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<`unit_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"unit">>;
+    name: import("zod").ZodDefault<import("zod").ZodString>;
+    kind: import("zod").ZodDefault<import("zod").ZodEnum<{
+        apartment: "apartment";
+        commercial: "commercial";
+        common: "common";
+        "hotel-room": "hotel-room";
+    }>>;
+    members: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`zone_${string}`>>>>;
+    color: import("zod").ZodDefault<import("zod").ZodString>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/unit/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAElF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAkC1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/unit/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

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

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

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

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

package/dist/unit/definition.edit.js

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