@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/stair/definition.js

@@ -1,443 +1,4 @@
-import { planStairSweepEdit, resolveStairTotalRise, resolveStairWinder, StairNode as StairNodeSchema, stairFootprintAABB, stairSlots, useScene, } from '@pascal-app/core';
-const MIN_CURVED_RISE = 0.001;
-const MIN_CURVED_WIDTH = 0.001;
-const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.001;
-const MIN_CURVED_INNER_RADIUS_CURVED = 0.001;
-const CURVED_RISE_OFFSET = 0.35;
-const CURVED_WIDTH_HANDLE_OFFSET = 0.5;
-const CURVED_RADIAL_OFFSET = 0.16;
-const CURVED_SWEEP_RADIAL_OFFSET = 0.3;
-const CURVED_SWEEP_LATERAL_OFFSET = 0.24;
-// Guide rings — outer hugs just outside the rim, inner sits inside the
-// pillar. Clamp inner so a tiny innerRadius (spiral default 0.05) doesn't
-// push the ring through the axis.
-const CURVED_OUTER_RING_OFFSET = 0.2;
-const CURVED_INNER_RING_OFFSET = 0.2;
-const CURVED_INNER_RING_MIN = 0.05;
-// Whole-stair rotation gizmo — curved two-headed arrow at a corner of
-// the footprint. Same pattern as elevator / column / shelf / roof-segment.
-const STAIR_ROTATE_CORNER_OFFSET = 0.4;
-const STAIR_ROTATE_RING_OFFSET = 0.08;
-const STAIR_MOVE_FRONT_OFFSET = 0.35;
-function readTotalRise(node) {
-    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.001);
-}
-function readCurvedStairGeometry(node) {
-    const isSpiral = node.stairType === 'spiral';
-    const stepCount = Math.max(2, Math.round(node.stepCount ?? 10));
-    const totalRise = readTotalRise(node);
-    const width = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
-    const minInnerRadius = isSpiral ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED;
-    const innerRadius = Math.max(minInnerRadius, node.innerRadius ?? 0.9);
-    const outerRadius = innerRadius + width;
-    const sweepAngle = node.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
-    const stepSweep = sweepAngle / stepCount;
-    return {
-        isSpiral,
-        stepCount,
-        totalRise,
-        innerRadius,
-        outerRadius,
-        width,
-        sweepAngle,
-        stepSweep,
-        midRadius: (innerRadius + outerRadius) / 2,
-        topAngle: sweepAngle / 2 - stepSweep / 2,
-        minInnerRadius,
-    };
-}
-function isCurvedOrSpiral(node) {
-    return node.stairType === 'curved' || node.stairType === 'spiral';
-}
-function rotateLocalXZ(x, z, angle) {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}
-function fallbackStraightStairMoveBounds(node) {
-    const width = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
-    const depth = Math.max(width, 1);
-    return {
-        minX: -width / 2,
-        maxX: width / 2,
-        minZ: 0,
-        maxZ: depth,
-        height: readTotalRise(node),
-    };
-}
-function readStraightStairMoveBounds(node, sceneApi) {
-    const segments = (node.children ?? [])
-        .map((childId) => sceneApi.get(childId))
-        .filter((child) => child?.type === 'stair-segment');
-    if (segments.length === 0)
-        return fallbackStraightStairMoveBounds(node);
-    const transforms = computeStairSegmentFloorStackTransforms(segments);
-    let minX = Number.POSITIVE_INFINITY;
-    let maxX = Number.NEGATIVE_INFINITY;
-    let minZ = Number.POSITIVE_INFINITY;
-    let maxZ = Number.NEGATIVE_INFINITY;
-    let height = 0;
-    segments.forEach((segment, index) => {
-        const transform = transforms[index];
-        if (!transform)
-            return;
-        const halfWidth = segment.width / 2;
-        const corners = resolveStairWinder(segment)?.footprint ??
-            [
-                [-halfWidth, 0],
-                [halfWidth, 0],
-                [-halfWidth, segment.length],
-                [halfWidth, segment.length],
-            ];
-        for (const [x, z] of corners) {
-            const [rx, rz] = rotateLocalXZ(x, z, transform.rotation);
-            minX = Math.min(minX, transform.position[0] + rx);
-            maxX = Math.max(maxX, transform.position[0] + rx);
-            minZ = Math.min(minZ, transform.position[2] + rz);
-            maxZ = Math.max(maxZ, transform.position[2] + rz);
-        }
-        height = Math.max(height, transform.position[1] + Math.max(segment.height, segment.thickness, 0.01));
-    });
-    if (![minX, maxX, minZ, maxZ].every(Number.isFinite)) {
-        return fallbackStraightStairMoveBounds(node);
-    }
-    return { minX, maxX, minZ, maxZ, height: Math.max(height, 0.1) };
-}
-function readStairMoveBounds(node, sceneApi) {
-    if (!isCurvedOrSpiral(node))
-        return readStraightStairMoveBounds(node, sceneApi);
-    const g = readCurvedStairGeometry(node);
-    return {
-        minX: -g.outerRadius,
-        maxX: g.outerRadius,
-        minZ: -g.outerRadius,
-        maxZ: g.outerRadius,
-        height: g.totalRise,
-    };
-}
-function curvedRiseHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_CURVED_RISE,
-        currentValue: readTotalRise,
-        apply: (_n, newRise) => ({ totalRise: newRise }),
-        placement: {
-            position: (n) => {
-                const g = readCurvedStairGeometry(n);
-                // Spiral: over the central pillar. Curved: above the upper step's
-                // midline so the arrow sits where users read "top of the run".
-                const x = g.isSpiral ? 0 : g.midRadius * Math.cos(g.topAngle);
-                const z = g.isSpiral ? 0 : g.midRadius * Math.sin(g.topAngle);
-                return [x, g.totalRise + CURVED_RISE_OFFSET, z];
-            },
-        },
-    };
-}
-function curvedWidthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'min',
-        min: MIN_CURVED_WIDTH,
-        currentValue: (n) => Math.max(n.width ?? 1, MIN_CURVED_WIDTH),
-        apply: (_n, newWidth) => ({ width: newWidth }),
-        placement: {
-            position: (n) => {
-                const g = readCurvedStairGeometry(n);
-                return [g.outerRadius + CURVED_WIDTH_HANDLE_OFFSET, g.totalRise / 2, 0];
-            },
-        },
-        // Outer guide ring — traces the rim while the user interacts with the
-        // width arrow so it's obvious which edge the drag affects.
-        decoration: {
-            kind: 'ring',
-            radius: (n) => readCurvedStairGeometry(n).outerRadius + CURVED_OUTER_RING_OFFSET,
-            y: (n) => readCurvedStairGeometry(n).totalRise / 2,
-        },
-    };
-}
-function curvedInnerRadiusHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'min',
-        min: (n) => n.stairType === 'spiral' ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED,
-        currentValue: (n) => {
-            const minIR = n.stairType === 'spiral' ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED;
-            return Math.max(minIR, n.innerRadius ?? 0.9);
-        },
-        // Adjusting innerRadius alone would also push outerRadius outward,
-        // visually moving the outside of the stair. Compensate by reducing
-        // width by the same amount so the outer rim stays put.
-        apply: (initial, newInner) => {
-            const g = readCurvedStairGeometry(initial);
-            const delta = newInner - g.innerRadius;
-            return {
-                innerRadius: newInner,
-                width: Math.max(MIN_CURVED_WIDTH, g.width - delta),
-            };
-        },
-        placement: {
-            position: (n) => {
-                const g = readCurvedStairGeometry(n);
-                return [g.innerRadius - CURVED_RADIAL_OFFSET, g.totalRise / 2, 0];
-            },
-            rotationY: () => Math.PI,
-        },
-        // Inner guide ring — traces the central pillar. Clamped so a tiny
-        // innerRadius doesn't pull the ring through the axis.
-        decoration: {
-            kind: 'ring',
-            radius: (n) => {
-                const g = readCurvedStairGeometry(n);
-                return Math.max(g.innerRadius - CURVED_INNER_RING_OFFSET, CURVED_INNER_RING_MIN);
-            },
-            y: (n) => readCurvedStairGeometry(n).totalRise / 2,
-        },
-    };
-}
-function curvedSweepHandle(end) {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        end,
-        apply: (initial, delta) => planStairSweepEdit(initial, delta, end),
-        placement: {
-            position: (n) => {
-                const g = readCurvedStairGeometry(n);
-                const sweepSign = Math.sign(g.sweepAngle) || 1;
-                const z = end === 'end'
-                    ? sweepSign * CURVED_SWEEP_LATERAL_OFFSET
-                    : -sweepSign * CURVED_SWEEP_LATERAL_OFFSET;
-                return [g.outerRadius + CURVED_SWEEP_RADIAL_OFFSET, g.totalRise / 2, z];
-            },
-            rotationY: (n) => {
-                const sweepSign = Math.sign(n.sweepAngle ?? Math.PI / 2) || 1;
-                return end === 'end' ? -sweepSign * (Math.PI / 2) : sweepSign * (Math.PI / 2);
-            },
-        },
-    };
-}
-// Whole-stair rotation gizmo. Lives on the stair parent so it rotates
-// straight + curved + spiral kinds the same way. For straight stairs the
-// gizmo anchors just outside the +X corner of the run start (the stair's
-// root sits at the bottom of the first segment, with the chain extending
-// along +Z). For curved / spiral the gizmo sits at the outer rim, at the
-// sweep-start side, where there's no other handle in the way. apply()
-// negates the cursor delta so dragging CCW (atan2 ticks +) rotates the
-// stair CCW around Y — same convention as elevator / column.
-function stairRotateGizmoPosition(n) {
-    if (isCurvedOrSpiral(n)) {
-        const g = readCurvedStairGeometry(n);
-        const radius = g.outerRadius + STAIR_ROTATE_CORNER_OFFSET;
-        // Sweep-start side in node-local frame. Sector is centred on
-        // local +X (sweep bisector = 0), so start = -sweep/2.
-        const angle = -g.sweepAngle / 2;
-        return [radius * Math.cos(angle), g.totalRise / 2, radius * Math.sin(angle)];
-    }
-    const width = Math.max(n.width ?? 1, MIN_CURVED_WIDTH);
-    const yMid = readTotalRise(n) / 2;
-    return [width / 2 + STAIR_ROTATE_CORNER_OFFSET, yMid, -STAIR_ROTATE_CORNER_OFFSET];
-}
-function stairRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            position: stairRotateGizmoPosition,
-            // The curved-arrow geometry's bow points along its local +X. Rotate
-            // the icon so the bow points radially outward — away from the
-            // stair's center — so the curve hugs the body's outline at the
-            // gizmo's corner instead of cutting into it. rotateY(−α) maps local
-            // +X to the outward radial direction (same handedness rule as
-            // elevator / column, but here the gizmo lands in different
-            // quadrants per stair kind so the tilt is position-derived rather
-            // than a fixed −π/4).
-            rotationY: (n) => {
-                const [px, , pz] = stairRotateGizmoPosition(n);
-                return -Math.atan2(pz, px);
-            },
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => {
-                if (isCurvedOrSpiral(n)) {
-                    const g = readCurvedStairGeometry(n);
-                    return g.outerRadius + STAIR_ROTATE_CORNER_OFFSET + STAIR_ROTATE_RING_OFFSET;
-                }
-                const width = Math.max(n.width ?? 1, MIN_CURVED_WIDTH);
-                return (Math.hypot(width / 2 + STAIR_ROTATE_CORNER_OFFSET, STAIR_ROTATE_CORNER_OFFSET) +
-                    STAIR_ROTATE_RING_OFFSET);
-            },
-            y: (n) => readTotalRise(n) / 2,
-        },
-    };
-}
-function stairMoveHandle() {
-    return {
-        // Tap-to-engage: hand the stair to its `MoveRoofTool` (same path the
-        // floating action menu's Move button takes via `setMovingNode`) so the
-        // 3D grip and the floating-UI button share one move flow — green
-        // bounding box, alignment guides, R/T rotation, click-to-commit.
-        kind: 'tap-action',
-        shape: 'move-cross',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMove(node),
-        placement: {
-            // Low to the floor at the front edge (matches the item move grip) so it
-            // reads as a floor-move grip and stays clear of the body resize / rotate
-            // handles that sit at mid-height.
-            position: (n, sceneApi) => {
-                const bounds = readStairMoveBounds(n, sceneApi);
-                return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + STAIR_MOVE_FRONT_OFFSET];
-            },
-        },
-    };
-}
-function stairHandles(node) {
-    // Straight stairs have no parent-level shape arrows — the segment
-    // children each render their own (width / length / height). Curved +
-    // spiral stairs use 5 arrows directly on the parent (no segments).
-    // The whole-stair rotation gizmo is universal: every stair kind
-    // exposes the same curved-arrow rotate handle.
-    const handles = [];
-    if (isCurvedOrSpiral(node)) {
-        handles.push(curvedRiseHandle(), curvedWidthHandle(), curvedInnerRadiusHandle(), curvedSweepHandle('start'), curvedSweepHandle('end'));
-    }
-    handles.push(stairRotateHandle(), stairMoveHandle());
-    return handles;
-}
-import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from '@pascal-app/core';
-import { buildStairFloorplan } from './floorplan.js';
-import { curvedStairInnerRadiusAffordance, curvedStairSweepAffordance, curvedStairWidthAffordance, segmentLengthAffordance, segmentWidthAffordance, stairRotateAffordance, } from './floorplan-affordances.js';
-import { stairFloorplanMoveTarget } from './floorplan-move.js';
-import { stairPaint } from './paint.js';
-import { stairParametrics } from './parametrics.js';
-import { StairNode } from './schema.js';
-/**
- * Stair — Stage A. Composite node like roof: owns overall framing,
- * `stair-segment` children own per-flight geometry. Wrap-exports the
- * legacy `StairRenderer` + `StairSystem`.
- */
-export const stairDefinition = {
-    kind: 'stair',
-    schemaVersion: 2,
-    schema: StairNode,
-    category: 'structure',
-    extensions: {
-        'pascal:editor/floorplan': {
-            linkedLevelIds: (node) => node.toLevelId && node.toLevelId !== node.parentId ? [node.toLevelId] : [],
-        },
-    },
-    snapProfile: 'structural',
-    // A footprint with a clear front: you approach a stair from the low end,
-    // which sits on the -Z side of the run (the run ascends along +Z). Show the
-    // floor facing triangle there, pointing out of the entry, while placing/moving.
-    facingIndicator: { reversed: true },
-    // Placed as a footprint (R/T rotates), not a directional draw → no angle-lock
-    // mode. The toolHints presence routes it through the contextual HUD so the
-    // snapping chip shows during placement.
-    snapDraftDirectional: false,
-    toolHints: [
-        { key: 'Left click', label: 'Place stairs' },
-        { key: 'R / T', label: 'Rotate' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    surfaceRole: 'joinery',
-    defaults: () => {
-        const stub = StairNodeSchema.parse({ id: 'stair_default', type: 'stair' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        reveal: { phase: 'circulation', style: 'drop', height: 2.5 },
-        revealOnEdit: [
-            'stairType',
-            'width',
-            'totalRise',
-            'stepCount',
-            'thickness',
-            'innerRadius',
-            'sweepAngle',
-            'railingMode',
-            'topLandingDepth',
-        ],
-        hostRefFields: ['destinationSurfaceId'],
-        surfacePlacement: 'floor-only',
-        selectable: { hitVolume: 'bbox' },
-        // A stair has no centred box footprint: straight = a cumulative
-        // `stair-segment` chain, curved / spiral = an annular sector. Hand the
-        // alignment bridge the resolved plan `aabb` directly (not a `box`) — the
-        // moving-anchor helper can relocate the same shape when a stair is being
-        // placed or dragged.
-        alignmentFootprint: (node, nodes) => {
-            const aabb = stairFootprintAABB(node, nodes);
-            return aabb ? { shape: 'aabb', ...aabb } : null;
-        },
-        duplicable: { subtree: true },
-        deletable: true,
-        floorPlaced: {
-            footprints: (node, ctx) => ctx ? getStairFloorPlacedFootprints(node, ctx.nodes) : [],
-        },
-        slots: (node) => stairSlots(node),
-        paint: stairPaint,
-    },
-    // Bespoke move shared with roof / roof-segment / stair-segment via
-    // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
-    // affordance lookup rather than a hardcoded dispatcher arm.
-    affordanceTools: {
-        move: () => import('../shared/move-roof-tool.js'),
-    },
-    tool: () => import('./tool.js'),
-    parametrics: stairParametrics,
-    handles: stairHandles,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 3,
-    },
-    // Stage C — stair is the parent; it walks its `stair-segment` children
-    // via `ctx.children` and emits the whole stack as one registry entry.
-    // Each flight's transform depends on every prior sibling's
-    // `length` / `height` / `attachmentSide`, so individual segments can't
-    // compute their own polygon in isolation. See
-    // `nodes/src/stair/floorplan.ts` for the emitter.
-    floorplan: buildStairFloorplan,
-    floorplanMoveTarget: stairFloorplanMoveTarget,
-    // 2D drag affordances mirror the 3D in-world arrows on selected stairs:
-    //   - `segment-width` / `segment-length` drive per-segment side & length
-    //     arrows on straight stairs (sister to `StairSegmentSideArrow` /
-    //     `StairSegmentLengthArrow` in stair-segment-handles.tsx).
-    //   - `curved-width` / `curved-inner-radius` / `curved-sweep` drive the
-    //     parent-stair arrows for curved & spiral kinds (sister to
-    //     `CurvedStairWidthArrow` / `CurvedStairInnerRadiusArrow` /
-    //     `CurvedStairSweepArrow`).
-    // Height / rise arrows from the 3D set don't translate — no vertical axis
-    // in the plan view.
-    floorplanAffordances: {
-        'segment-width': segmentWidthAffordance,
-        'segment-length': segmentLengthAffordance,
-        'curved-width': curvedStairWidthAffordance,
-        'curved-inner-radius': curvedStairInnerRadiusAffordance,
-        'curved-sweep': curvedStairSweepAffordance,
-        'stair-rotate': stairRotateAffordance,
-    },
-    presentation: {
-        label: 'Stair',
-        description: 'A stair composed of one or more flights with configurable treads, risers, railings.',
-        icon: { kind: 'url', src: '/icons/stairs.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 110,
-    },
-    mcp: {
-        description: 'A multi-flight stair with segmented geometry.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { stairEditContribution } from './definition.edit.js';
+import { stairRenderDefinition } from './definition.render.js';
+export const stairDefinition = composeNodeDefinition(stairRenderDefinition, stairEditContribution);

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

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

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

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

package/dist/stair/definition.render.js

@@ -0,0 +1,65 @@
+import { getStairFloorPlacedFootprints, StairNode as StairNodeSchema, stairFootprintAABB, stairSlots, } from '@pascal-app/core';
+import { StairNode } from './schema.js';
+export const stairRenderDefinition = {
+    kind: 'stair',
+    schemaVersion: 2,
+    schema: StairNode,
+    category: 'structure',
+    surfaceRole: 'joinery',
+    defaults: () => {
+        const stub = StairNodeSchema.parse({ id: 'stair_default', type: 'stair' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        reveal: { phase: 'circulation', style: 'drop', height: 2.5 },
+        revealOnEdit: [
+            'stairType',
+            'width',
+            'totalRise',
+            'stepCount',
+            'thickness',
+            'innerRadius',
+            'sweepAngle',
+            'railingMode',
+            'topLandingDepth',
+        ],
+        hostRefFields: ['destinationSurfaceId'],
+        surfacePlacement: 'floor-only',
+        selectable: { hitVolume: 'bbox' },
+        // A stair has no centred box footprint: straight = a cumulative
+        // `stair-segment` chain, curved / spiral = an annular sector. Hand the
+        // alignment bridge the resolved plan `aabb` directly (not a `box`) — the
+        // moving-anchor helper can relocate the same shape when a stair is being
+        // placed or dragged.
+        alignmentFootprint: (node, nodes) => {
+            const aabb = stairFootprintAABB(node, nodes);
+            return aabb ? { shape: 'aabb', ...aabb } : null;
+        },
+        duplicable: { subtree: true },
+        deletable: true,
+        floorPlaced: {
+            footprints: (node, ctx) => ctx ? getStairFloorPlacedFootprints(node, ctx.nodes) : [],
+        },
+        slots: (node) => stairSlots(node),
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Stair',
+        description: 'A stair composed of one or more flights with configurable treads, risers, railings.',
+        icon: { kind: 'url', src: '/icons/stairs.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 110,
+    },
+    mcp: {
+        description: 'A multi-flight stair with segmented geometry.',
+    },
+};

package/dist/stair/paint.d.ts

@@ -6,6 +6,7 @@ export declare const stairSegmentPaint: {
     roomScope?: boolean;
     resolveRole: (args: PaintResolveArgs) => string | null;
     roleLabel?: (node: AnyNode, role: string) => string | null;
+    scopes?: (node: AnyNode, role: string) => import("@pascal-app/core").PaintSurfaceScopes | null;
     buildPatch: (args: import("@pascal-app/core").PaintPatchArgs) => Partial<AnyNode>;
     commit?: (args: import("@pascal-app/core").PaintPatchArgs) => void;
     applyPreview: (args: PaintPreviewArgs) => (() => void) | null;
@@ -25,6 +26,11 @@ export declare const stairSegmentPaint: {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset: string | undefined;

package/dist/stair/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/stair/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAwHzB,eAAO,MAAM,UAAU,4CAKrB,CAAA;AAEF,QAAA,MAAM,YAAY,4CAMhB,CAAA;AACF,eAAO,MAAM,iBAAiB;;;;;;;;iCAGpB,UAAU,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;CAa7E,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/stair/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAwHzB,eAAO,MAAM,UAAU,4CAKrB,CAAA;AAEF,QAAA,MAAM,YAAY,4CAMhB,CAAA;AACF,eAAO,MAAM,iBAAiB;;;;;;;;;iCAGpB,UAAU,CAAC,WAAW,CAAC,OAAO,YAAY,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAa7E,CAAA"}

package/dist/stair/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair/panel.tsx"],"names":[],"mappings":"AA4FA,MAAM,CAAC,OAAO,UAAU,UAAU,uCAo4BjC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair/panel.tsx"],"names":[],"mappings":"AAkKA,MAAM,CAAC,OAAO,UAAU,UAAU,uCA2hCjC"}