@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/block/modal-session.d.ts

@@ -0,0 +1,15 @@
+import type { SelectionAffordanceInteractionApi } from '@pascal-app/editor';
+import type { MutableRefObject } from 'react';
+type FinishModal = (commit: boolean) => void;
+export type BlockModalSessionOptions = {
+    beginInputDrag: SelectionAffordanceInteractionApi['beginInputDrag'];
+    cancelRef: MutableRefObject<(() => void) | null>;
+    cursor: string;
+    onFinish: (commit: boolean) => void;
+    onKeyDown?: (event: KeyboardEvent, finish: FinishModal) => void;
+    onPointerDown?: (event: PointerEvent, finish: FinishModal) => void;
+    onPointerMove?: (event: PointerEvent) => void;
+};
+export declare function beginBlockModalSession({ beginInputDrag, cancelRef, cursor, onFinish, onKeyDown, onPointerDown, onPointerMove, }: BlockModalSessionOptions): FinishModal;
+export {};
+//# sourceMappingURL=modal-session.d.ts.map

package/dist/block/modal-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-session.d.ts","sourceRoot":"","sources":["../../src/block/modal-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAA;AAC3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAA;AAE7C,KAAK,WAAW,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;AAE5C,MAAM,MAAM,wBAAwB,GAAG;IACrC,cAAc,EAAE,iCAAiC,CAAC,gBAAgB,CAAC,CAAA;IACnE,SAAS,EAAE,gBAAgB,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAA;IAChD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACnC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;IAC/D,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;IAClE,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CAC9C,CAAA;AAED,wBAAgB,sBAAsB,CAAC,EACrC,cAAc,EACd,SAAS,EACT,MAAM,EACN,QAAQ,EACR,SAAS,EACT,aAAa,EACb,aAAa,GACd,EAAE,wBAAwB,GAAG,WAAW,CAmCxC"}

package/dist/block/modal-session.js

@@ -0,0 +1,40 @@
+export function beginBlockModalSession({ beginInputDrag, cancelRef, cursor, onFinish, onKeyDown, onPointerDown, onPointerMove, }) {
+    const restoreInputDragging = beginInputDrag();
+    const previousCursor = document.body.style.cursor;
+    let finished = false;
+    const onContextMenu = (event) => {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+    };
+    const onCancel = () => finish(false);
+    const pointerDown = (event) => onPointerDown?.(event, finish);
+    const keyDown = (event) => onKeyDown?.(event, finish);
+    function finish(commit) {
+        if (finished)
+            return;
+        finished = true;
+        if (onPointerMove)
+            window.removeEventListener('pointermove', onPointerMove, true);
+        if (onPointerDown)
+            window.removeEventListener('pointerdown', pointerDown, true);
+        if (onKeyDown)
+            window.removeEventListener('keydown', keyDown, true);
+        window.removeEventListener('contextmenu', onContextMenu, true);
+        window.removeEventListener('blur', onCancel);
+        cancelRef.current = null;
+        restoreInputDragging();
+        document.body.style.cursor = previousCursor;
+        onFinish(commit);
+    }
+    document.body.style.cursor = cursor;
+    cancelRef.current = onCancel;
+    if (onPointerMove)
+        window.addEventListener('pointermove', onPointerMove, true);
+    if (onPointerDown)
+        window.addEventListener('pointerdown', pointerDown, true);
+    if (onKeyDown)
+        window.addEventListener('keydown', keyDown, true);
+    window.addEventListener('contextmenu', onContextMenu, true);
+    window.addEventListener('blur', onCancel, { once: true });
+    return finish;
+}

package/dist/block/modal-transform.d.ts

@@ -0,0 +1,30 @@
+export type BlockTransformAxis = 'x' | 'y' | 'z';
+export type BlockTransformPlane = 'xy' | 'xz' | 'yz';
+export type BlockTransformOperation = 'translate' | 'rotate' | 'scale';
+export type BlockTransformConstraint = BlockTransformAxis | BlockTransformPlane | 'free' | 'uniform';
+export type BlockModalFeedbackMode = 'free' | 'grid' | 'angle' | 'exact' | 'geometry';
+export type BlockActiveTransform = {
+    operation: BlockTransformOperation;
+    constraint: BlockTransformConstraint;
+};
+export type BlockAxisVisualState = 'normal' | 'active' | 'faded';
+export type BlockScreenPoint = {
+    x: number;
+    y: number;
+};
+export declare function blockRotationPointerAngle(pivot: BlockScreenPoint, start: BlockScreenPoint, current: BlockScreenPoint): number;
+export declare function blockTransformAxisFromKey(key: string): BlockTransformAxis | null;
+export declare function blockTransformConstraintFromKey(key: string, planeLock: boolean): BlockTransformAxis | BlockTransformPlane | null;
+export declare function blockTransformNumericInputFromKey(current: string, key: string): string | null;
+export declare function blockTransformNumericValue(input: string, operation: BlockTransformOperation): number | null;
+export declare function blockTransformDisplayValue(operation: BlockTransformOperation, value: number): string;
+export declare function blockModalFeedbackLabel(mode: BlockModalFeedbackMode): string;
+export declare function blockAxisDelta(axis: BlockTransformAxis, distance: number): [number, number, number];
+export declare function blockPointerDistanceForAxis(_axis: BlockTransformAxis, distance: number): number;
+export declare function blockConstrainTranslationDelta(delta: [number, number, number], constraint: BlockTransformConstraint): [number, number, number];
+export declare function blockNumericDeltaForConstraint(constraint: BlockTransformConstraint, pointerDelta: [number, number, number], distance: number): [number, number, number];
+export declare function blockScaleFactorsForConstraint(constraint: BlockTransformConstraint, factor: number): [number, number, number];
+export declare function blockAxisVisualState(activeTransform: BlockActiveTransform | null, operation: BlockTransformOperation, axis: BlockTransformAxis): BlockAxisVisualState;
+export declare function blockPlaneVisualState(activeTransform: BlockActiveTransform | null, plane: BlockTransformPlane): BlockAxisVisualState;
+export declare function blockModalTransformStatus(activeTransform: BlockActiveTransform, typedInput?: string, feedbackMode?: BlockModalFeedbackMode): string;
+//# sourceMappingURL=modal-transform.d.ts.map

package/dist/block/modal-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-transform.d.ts","sourceRoot":"","sources":["../../src/block/modal-transform.ts"],"names":[],"mappings":"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"}

package/dist/block/modal-transform.js

@@ -0,0 +1,144 @@
+export function blockRotationPointerAngle(pivot, start, current) {
+    const startDistanceSquared = (start.x - pivot.x) ** 2 + (start.y - pivot.y) ** 2;
+    if (startDistanceSquared < 64) {
+        return (current.x - start.x - (current.y - start.y)) * 0.01;
+    }
+    return (Math.atan2(current.y - pivot.y, current.x - pivot.x) -
+        Math.atan2(start.y - pivot.y, start.x - pivot.x));
+}
+export function blockTransformAxisFromKey(key) {
+    const normalized = key.toLowerCase();
+    return normalized === 'x' || normalized === 'y' || normalized === 'z' ? normalized : null;
+}
+export function blockTransformConstraintFromKey(key, planeLock) {
+    const axis = blockTransformAxisFromKey(key);
+    if (!axis || !planeLock)
+        return axis;
+    return axis === 'x' ? 'yz' : axis === 'y' ? 'xz' : 'xy';
+}
+export function blockTransformNumericInputFromKey(current, key) {
+    if (/^\d$/.test(key))
+        return `${current}${key}`;
+    if (key === '.') {
+        if (current.includes('.'))
+            return current;
+        if (current === '')
+            return '0.';
+        if (current === '-')
+            return '-0.';
+        return `${current}.`;
+    }
+    if (key === '-')
+        return current.startsWith('-') ? current.slice(1) : `-${current}`;
+    if (key === 'Backspace')
+        return current.slice(0, -1);
+    return null;
+}
+export function blockTransformNumericValue(input, operation) {
+    if (input === '' || input === '-' || input === '.' || input === '-.')
+        return null;
+    const value = Number(input);
+    if (!Number.isFinite(value))
+        return null;
+    return operation === 'rotate' ? (value * Math.PI) / 180 : value;
+}
+export function blockTransformDisplayValue(operation, value) {
+    const displayed = operation === 'rotate' ? (value * 180) / Math.PI : value;
+    return String(Math.round(displayed * 1000) / 1000);
+}
+export function blockModalFeedbackLabel(mode) {
+    return mode === 'grid'
+        ? 'Grid snap'
+        : mode === 'angle'
+            ? 'Angle snap'
+            : mode === 'exact'
+                ? 'Exact'
+                : mode === 'geometry'
+                    ? 'Geometry snap'
+                    : 'Free';
+}
+export function blockAxisDelta(axis, distance) {
+    return [axis === 'x' ? distance : 0, axis === 'y' ? distance : 0, axis === 'z' ? distance : 0];
+}
+export function blockPointerDistanceForAxis(_axis, distance) {
+    return distance;
+}
+export function blockConstrainTranslationDelta(delta, constraint) {
+    if (constraint === 'free' || constraint === 'uniform')
+        return delta;
+    return delta.map((value, index) => {
+        const axis = index === 0 ? 'x' : index === 1 ? 'y' : 'z';
+        return constraint.includes(axis) ? value : 0;
+    });
+}
+export function blockNumericDeltaForConstraint(constraint, pointerDelta, distance) {
+    if (constraint === 'x' || constraint === 'y' || constraint === 'z') {
+        return blockAxisDelta(constraint, distance);
+    }
+    if (constraint === 'xy' || constraint === 'xz' || constraint === 'yz') {
+        const delta = [
+            constraint.includes('x') ? pointerDelta[0] : 0,
+            constraint.includes('y') ? pointerDelta[1] : 0,
+            constraint.includes('z') ? pointerDelta[2] : 0,
+        ];
+        const length = Math.hypot(...delta);
+        if (length > 1e-8)
+            return delta.map((value) => (value / length) * distance);
+        return blockAxisDelta(constraint[0], distance);
+    }
+    return blockAxisDelta('x', distance);
+}
+export function blockScaleFactorsForConstraint(constraint, factor) {
+    if (constraint === 'uniform' || constraint === 'free')
+        return [factor, factor, factor];
+    return [
+        constraint.includes('x') ? factor : 1,
+        constraint.includes('y') ? factor : 1,
+        constraint.includes('z') ? factor : 1,
+    ];
+}
+export function blockAxisVisualState(activeTransform, operation, axis) {
+    if (!activeTransform)
+        return 'normal';
+    if (activeTransform.operation !== operation)
+        return 'faded';
+    if (activeTransform.constraint === 'free' || activeTransform.constraint === 'uniform') {
+        return 'normal';
+    }
+    if (activeTransform.constraint.length === 2) {
+        return activeTransform.constraint.includes(axis) ? 'active' : 'faded';
+    }
+    return activeTransform.constraint === axis ? 'active' : 'faded';
+}
+export function blockPlaneVisualState(activeTransform, plane) {
+    if (!activeTransform)
+        return 'normal';
+    if (activeTransform.operation !== 'translate' ||
+        activeTransform.constraint === 'uniform' ||
+        activeTransform.constraint === 'free') {
+        return activeTransform.constraint === 'free' ? 'normal' : 'faded';
+    }
+    return activeTransform.constraint === plane ? 'active' : 'faded';
+}
+export function blockModalTransformStatus(activeTransform, typedInput = '', feedbackMode = 'free') {
+    const operation = activeTransform.operation === 'translate'
+        ? 'Move'
+        : activeTransform.operation === 'rotate'
+            ? 'Rotate'
+            : 'Scale';
+    const constraint = activeTransform.constraint === 'free'
+        ? 'free'
+        : activeTransform.constraint === 'uniform'
+            ? 'uniform'
+            : activeTransform.constraint.length === 2
+                ? `${activeTransform.constraint.toUpperCase()} plane`
+                : `${activeTransform.constraint.toUpperCase()} axis`;
+    const typedValue = typedInput
+        ? ` · ${typedInput}${activeTransform.operation === 'translate'
+            ? ' m'
+            : activeTransform.operation === 'rotate'
+                ? '°'
+                : '×'}`
+        : '';
+    return `${operation} · ${constraint}${typedValue} · ${blockModalFeedbackLabel(feedbackMode)} · X/Y/Z constrains · click applies · Esc cancels`;
+}

package/dist/block/paint.d.ts

@@ -0,0 +1,3 @@
+import { type PaintCapability } from '@pascal-app/core';
+export declare const blockPaint: PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/block/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAgIzB,eAAO,MAAM,UAAU,EAAE,eAcxB,CAAA"}

package/dist/block/paint.js

@@ -0,0 +1,136 @@
+import { parseMaterialRef, useScene, } from '@pascal-app/core';
+import { Raycaster } from 'three';
+import { buildSlotPreviewMaterial, resolveSlotPaintMaterialRef } from '../shared/slot-paint';
+import { BLOCK_BODY_SLOT_ID, blockMaterialSlotIds, setBlockMaterialSlot } from './material-slots';
+const blockPaintRaycaster = new Raycaster();
+function blockFaceRanges(mesh) {
+    const ranges = mesh.geometry.userData.blockFaces;
+    return Array.isArray(ranges) ? ranges : [];
+}
+function resolveBlockPaintRole(args) {
+    const mesh = args.hitObject;
+    if (!(mesh?.isMesh && args.ray))
+        return null;
+    mesh.updateWorldMatrix(true, false);
+    blockPaintRaycaster.ray.copy(args.ray);
+    const hit = blockPaintRaycaster.intersectObject(mesh, false)[0];
+    if (hit?.faceIndex == null)
+        return null;
+    const triangleStart = hit.faceIndex * 3;
+    const range = blockFaceRanges(mesh).find((candidate) => triangleStart >= candidate.start && triangleStart < candidate.start + candidate.count);
+    return range
+        ? (args.node.topology.faces.find((face) => face.id === range.faceId)
+            ?.materialSlot ?? null)
+        : null;
+}
+function paintBlockSlot(node, slotId, materialRef) {
+    if (!blockMaterialSlotIds(node.topology, node.slots, node.slotNames).includes(slotId)) {
+        return null;
+    }
+    return setBlockMaterialSlot(node.slots, slotId, materialRef);
+}
+function buildBlockFacePaintPatch(args) {
+    const node = args.node;
+    if (args.material && !args.materialPreset)
+        return {};
+    const result = paintBlockSlot(node, args.role, args.materialPreset);
+    return result?.changed ? { slots: result.slots } : {};
+}
+function commitBlockFacePaint(args) {
+    const nodeId = args.node.id;
+    const state = useScene.getState();
+    const current = state.nodes[nodeId];
+    if (current?.type !== 'block')
+        return;
+    const resolution = resolveSlotPaintMaterialRef(state.materials, args.material, args.materialPreset);
+    if (!resolution)
+        return;
+    const result = paintBlockSlot(current, args.role, resolution.ref);
+    if (!result?.changed)
+        return;
+    let committed = false;
+    useScene.setState((scene) => {
+        if (scene.readOnly || scene.nodes[nodeId]?.type !== 'block')
+            return scene;
+        committed = true;
+        return {
+            materials: resolution.newSceneMaterial
+                ? {
+                    ...scene.materials,
+                    [resolution.newSceneMaterial.id]: resolution.newSceneMaterial,
+                }
+                : scene.materials,
+            nodes: {
+                ...scene.nodes,
+                [nodeId]: {
+                    ...scene.nodes[nodeId],
+                    slots: result.slots,
+                },
+            },
+        };
+    });
+    if (committed)
+        useScene.getState().markDirty(nodeId);
+}
+function previewBlockFace(args) {
+    const preview = buildSlotPreviewMaterial(args.material, args.materialPreset);
+    if (!preview)
+        return () => { };
+    const node = args.node;
+    const faceIds = new Set(node.topology.faces.filter((face) => face.materialSlot === args.role).map((face) => face.id));
+    if (faceIds.size === 0)
+        return null;
+    const restores = [];
+    args.root.traverse((object) => {
+        const mesh = object;
+        if (!mesh.isMesh || mesh.userData.__fromGeometry !== true)
+            return;
+        const ranges = blockFaceRanges(mesh).filter((candidate) => faceIds.has(candidate.faceId));
+        if (ranges.length === 0)
+            return;
+        const materialGroups = ranges.flatMap((range) => mesh.geometry.groups.filter((group) => group.start === range.start && group.count === range.count));
+        if (materialGroups.length === 0)
+            return;
+        const previousMaterial = mesh.material;
+        const previousMaterialIndices = materialGroups.map((group) => group.materialIndex);
+        const slotIds = mesh.userData.slotIds;
+        const next = Array.isArray(previousMaterial)
+            ? previousMaterial.slice()
+            : Array.isArray(slotIds)
+                ? slotIds.map(() => previousMaterial)
+                : [previousMaterial];
+        for (const materialGroup of materialGroups)
+            materialGroup.materialIndex = next.length;
+        mesh.material = [...next, preview];
+        restores.push(() => {
+            materialGroups.forEach((group, index) => {
+                group.materialIndex = previousMaterialIndices[index];
+            });
+            mesh.material = previousMaterial;
+        });
+    });
+    if (restores.length === 0)
+        return null;
+    return () => {
+        for (let index = restores.length - 1; index >= 0; index -= 1)
+            restores[index]?.();
+    };
+}
+export const blockPaint = {
+    resolveRole: resolveBlockPaintRole,
+    buildPatch: buildBlockFacePaintPatch,
+    commit: commitBlockFacePaint,
+    applyPreview: previewBlockFace,
+    getEffectiveMaterial: ({ node, role }) => {
+        if (node.type !== 'block')
+            return null;
+        const ref = node.slots?.[role] ?? node.slots?.[BLOCK_BODY_SLOT_ID];
+        const parsed = parseMaterialRef(ref);
+        if (!parsed)
+            return null;
+        if (parsed.kind === 'library')
+            return { material: undefined, materialPreset: ref };
+        const sceneMaterial = useScene.getState().materials[parsed.id];
+        return sceneMaterial ? { material: sceneMaterial.material, materialPreset: undefined } : null;
+    },
+};

package/dist/block/panel.d.ts

@@ -0,0 +1,2 @@
+export default function BlockPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/block/panel.tsx"],"names":[],"mappings":"AAqFA,MAAM,CAAC,OAAO,UAAU,UAAU,uCA4UjC"}

package/dist/block/panel.js

@@ -0,0 +1,234 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getCatalogMaterialById, parseMaterialRef, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, createEditorApi, PanelSection, PanelWrapper, SliderControl, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Check, Move, Plus, Trash2 } from 'lucide-react';
+import { useCallback, useRef, useState } from 'react';
+import { resolveSlotPaintMaterialRef } from '../shared/slot-paint';
+import useBlockEditSession from './edit-session';
+import { assignBlockMaterial, BLOCK_BODY_SLOT_ID, blockMaterialSelection, createAssignedBlockMaterialSlot, removeBlockMaterialSlot, renameBlockMaterialSlot, } from './material-slots';
+import { blockSlots } from './slots';
+const SLOT_TRAILING_ACTION_CLASS = 'm-2 ml-0 flex w-8 shrink-0 items-center justify-center rounded-md';
+const SLOT_DISABLED_ACTION_CLASS = 'disabled:cursor-not-allowed disabled:opacity-45 disabled:hover:bg-[#2C2C2E] disabled:active:bg-[#2C2C2E]';
+const NEW_BLOCK_SLOT_MATERIAL = {
+    preset: 'custom',
+    properties: {
+        color: '#7768d8',
+        roughness: 0.75,
+        metalness: 0,
+        opacity: 1,
+        transparent: false,
+        side: 'front',
+    },
+};
+function materialRefLabel(ref, sceneMaterials) {
+    const parsed = parseMaterialRef(ref);
+    if (!parsed)
+        return 'Default material';
+    if (parsed.kind === 'scene')
+        return sceneMaterials[parsed.id]?.name ?? ref ?? parsed.id;
+    return getCatalogMaterialById(parsed.id)?.label ?? ref ?? parsed.id;
+}
+function materialRefPreview(ref, sceneMaterials) {
+    const parsed = parseMaterialRef(ref);
+    if (!parsed)
+        return { color: '#71717a' };
+    if (parsed.kind === 'scene') {
+        const material = sceneMaterials[parsed.id]?.material;
+        return {
+            color: material?.properties?.color ?? '#71717a',
+            imageUrl: material?.texture?.url,
+        };
+    }
+    const catalogMaterial = getCatalogMaterialById(parsed.id);
+    return {
+        color: catalogMaterial?.previewColor ?? catalogMaterial?.preset.mapProperties.color ?? '#71717a',
+        imageUrl: catalogMaterial?.previewThumbnailUrl,
+    };
+}
+export default function BlockPanel() {
+    const selectedId = useViewer((state) => state.selection.selectedIds[0]);
+    const setViewerSelection = useViewer((state) => state.setSelection);
+    const node = useScene((state) => {
+        if (!selectedId)
+            return null;
+        const selected = state.nodes[selectedId];
+        return selected?.type === 'block' ? selected : null;
+    });
+    const nodeRef = useRef(node);
+    nodeRef.current = node;
+    const sceneMaterials = useScene((state) => state.materials);
+    const readOnly = useScene((state) => state.readOnly);
+    const editing = useInteractionScope((state) => state.scope.kind === 'mesh-editing' && state.scope.nodeId === selectedId);
+    const sessionNodeId = useBlockEditSession((state) => state.nodeId);
+    const selection = useBlockEditSession((state) => state.selection);
+    const [slotNotice, setSlotNotice] = useState(null);
+    const close = useCallback(() => {
+        setViewerSelection({ selectedIds: [] });
+    }, [setViewerSelection]);
+    const move = useCallback(() => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        triggerSFX('sfx:item-pick');
+        createEditorApi().engageMove(current);
+        setViewerSelection({ selectedIds: [] });
+    }, [setViewerSelection]);
+    const updatePositionX = useCallback((value) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        useScene.getState().updateNode(current.id, {
+            position: [value, current.position[1], current.position[2]],
+        });
+    }, []);
+    const updatePositionY = useCallback((value) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        useScene.getState().updateNode(current.id, {
+            position: [current.position[0], value, current.position[2]],
+        });
+    }, []);
+    const updatePositionZ = useCallback((value) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        useScene.getState().updateNode(current.id, {
+            position: [current.position[0], current.position[1], value],
+        });
+    }, []);
+    if (!node)
+        return null;
+    const selectedFaceIds = editing && sessionNodeId === node.id && selection.mode === 'face' ? selection.ids : [];
+    const materialSelection = blockMaterialSelection(node.topology, selectedFaceIds, selection.activeId);
+    const slotDeclarations = blockSlots(node);
+    const canOperateOnFaces = editing && selection.mode === 'face';
+    const slotEditTitle = !editing
+        ? 'Enter Edit Mode to use slot actions'
+        : readOnly
+            ? 'Scene is read-only'
+            : undefined;
+    const faceCountBySlot = new Map();
+    for (const face of node.topology.faces) {
+        faceCountBySlot.set(face.materialSlot, (faceCountBySlot.get(face.materialSlot) ?? 0) + 1);
+    }
+    const addMaterialSlot = () => {
+        const scene = useScene.getState();
+        const resolution = resolveSlotPaintMaterialRef(scene.materials, NEW_BLOCK_SLOT_MATERIAL, undefined);
+        if (!resolution?.ref)
+            return;
+        const result = createAssignedBlockMaterialSlot(node.topology, node.slots, node.slotNames, selectedFaceIds, resolution.ref);
+        if (!result.changed)
+            return;
+        let committed = false;
+        useScene.setState((current) => {
+            if (current.readOnly || current.nodes[node.id]?.type !== 'block')
+                return current;
+            committed = true;
+            return {
+                materials: resolution.newSceneMaterial
+                    ? {
+                        ...current.materials,
+                        [resolution.newSceneMaterial.id]: {
+                            ...resolution.newSceneMaterial,
+                            name: 'Block Accent',
+                        },
+                    }
+                    : current.materials,
+                nodes: {
+                    ...current.nodes,
+                    [node.id]: {
+                        ...current.nodes[node.id],
+                        topology: result.topology,
+                        slots: result.slots,
+                        slotNames: result.slotNames,
+                    },
+                },
+            };
+        });
+        if (!committed)
+            return;
+        useScene.getState().markDirty(node.id);
+        const faceLabel = selectedFaceIds.length === 1 ? 'face' : 'faces';
+        setSlotNotice({
+            nodeId: node.id,
+            text: `${result.slotNames[result.slotId] ?? result.slotId} applied to ${selectedFaceIds.length} ${faceLabel} with an accent material. Use Paint (P) to replace it.`,
+        });
+        triggerSFX('sfx:menu-click');
+    };
+    const renameMaterialSlot = (slotId, name) => {
+        const slotNames = renameBlockMaterialSlot(node.topology, node.slots, node.slotNames, slotId, name);
+        if (slotNames === node.slotNames)
+            return;
+        useScene.getState().updateNode(node.id, { slotNames });
+    };
+    const assignSlot = (slotId) => {
+        setSlotNotice(null);
+        const result = assignBlockMaterial(node.topology, node.slots, selectedFaceIds, {
+            kind: 'slot',
+            slotId,
+        }, node.slotNames);
+        if (!result.changed)
+            return;
+        useScene.getState().updateNode(node.id, {
+            topology: result.topology,
+            slots: result.slots,
+        });
+        triggerSFX('sfx:menu-click');
+    };
+    const removeMaterialSlot = (slotId) => {
+        const result = removeBlockMaterialSlot(node.topology, node.slots, slotId, node.slotNames);
+        if (!result.changed)
+            return;
+        useScene.getState().updateNode(node.id, {
+            topology: result.topology,
+            slots: result.slots,
+            slotNames: result.slotNames,
+        });
+        setSlotNotice(null);
+        triggerSFX('sfx:menu-click');
+    };
+    const selectionLabel = !editing
+        ? 'Enter Edit Mode to assign faces'
+        : selection.mode !== 'face'
+            ? 'Switch to Face Select (3)'
+            : materialSelection.kind === 'empty'
+                ? 'No faces selected'
+                : materialSelection.kind === 'mixed'
+                    ? `${selectedFaceIds.length} faces · Mixed slots`
+                    : `${selectedFaceIds.length} ${selectedFaceIds.length === 1 ? 'face' : 'faces'} · ${slotDeclarations.find((slot) => slot.slotId === materialSelection.slotId)?.label ?? materialSelection.slotId}`;
+    return (_jsxs(PanelWrapper, { icon: "/icons/cube.webp", onClose: close, title: node.name || 'Block', width: 340, children: [_jsx(PanelSection, { title: "Position", children: [
+                    { axis: 0, label: 'X', onChange: updatePositionX },
+                    { axis: 1, label: 'Y', onChange: updatePositionY },
+                    { axis: 2, label: 'Z', onChange: updatePositionZ },
+                ].map(({ axis, label, onChange }) => (_jsx(SliderControl, { label: label, onChange: onChange, precision: 2, step: 0.01, unit: "m", value: node.position[axis] }, label))) }), _jsxs(PanelSection, { title: "Slots", children: [_jsx("div", { className: "rounded-md border border-border/50 bg-background/40 px-2.5 py-2 text-muted-foreground text-xs", children: selectionLabel }), _jsx("div", { className: "mt-2 flex justify-end", children: _jsx(ActionButton, { className: SLOT_DISABLED_ACTION_CLASS, disabled: !canOperateOnFaces || selectedFaceIds.length === 0 || readOnly, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add slot", onClick: addMaterialSlot, title: slotEditTitle ??
+                                (selectedFaceIds.length === 0 ? 'Select one or more faces first' : undefined) }) }), slotNotice?.nodeId === node.id ? (_jsx("div", { "aria-live": "polite", className: "mt-2 rounded-md border border-primary/35 bg-primary/10 px-2.5 py-2 text-foreground text-xs", children: slotNotice.text })) : null, _jsx("div", { className: "mt-2 max-h-44 overflow-y-auto rounded-lg border border-border/60 bg-[#252527]", children: slotDeclarations.map((slot, index) => {
+                            const ref = node.slots?.[slot.slotId];
+                            const active = materialSelection.kind === 'single' && materialSelection.slotId === slot.slotId;
+                            const preview = materialRefPreview(ref, sceneMaterials);
+                            const faceCount = faceCountBySlot.get(slot.slotId) ?? 0;
+                            const materialLabel = ref || slot.slotId === BLOCK_BODY_SLOT_ID
+                                ? materialRefLabel(ref, sceneMaterials)
+                                : 'Unpainted';
+                            return (_jsxs("div", { className: `group relative flex min-h-11 items-stretch border-border/50 ${index > 0 ? 'border-t' : ''} ${active ? 'bg-primary/15' : 'hover:bg-white/[0.035]'}`, children: [_jsx("button", { className: "absolute inset-0 z-0 rounded-none disabled:cursor-not-allowed disabled:opacity-50", "aria-label": `Apply ${slot.label} to selected faces`, "aria-pressed": active, disabled: !canOperateOnFaces || selectedFaceIds.length === 0 || readOnly, onClick: () => assignSlot(slot.slotId), type: "button" }), _jsx("span", { className: "pointer-events-none relative z-10 flex w-12 shrink-0 items-center justify-center", children: _jsx("span", { className: "h-7 w-7 shrink-0 rounded-md border border-white/10 bg-cover bg-center shadow-inner", style: {
+                                                backgroundColor: !ref && slot.slotId !== BLOCK_BODY_SLOT_ID ? '#7768d8' : preview.color,
+                                                backgroundImage: preview.imageUrl ? `url(${preview.imageUrl})` : undefined,
+                                            } }) }), _jsxs("span", { className: "pointer-events-none relative z-10 flex min-w-0 flex-1 flex-col justify-center py-1.5", children: [_jsx("input", { "aria-label": `Rename ${slot.label} slot`, className: "pointer-events-auto h-5 min-w-0 rounded bg-transparent px-1 font-medium text-foreground text-xs outline-none focus:bg-background/70 focus:ring-1 focus:ring-primary/50 disabled:cursor-not-allowed", defaultValue: slot.label, disabled: !editing || readOnly, onBlur: (event) => {
+                                                    if (!event.currentTarget.value.trim())
+                                                        event.currentTarget.value = slot.label;
+                                                    renameMaterialSlot(slot.slotId, event.currentTarget.value);
+                                                }, onKeyDown: (event) => {
+                                                    if (event.key === 'Enter')
+                                                        event.currentTarget.blur();
+                                                    if (event.key === 'Escape') {
+                                                        event.currentTarget.value = slot.label;
+                                                        event.currentTarget.blur();
+                                                    }
+                                                } }, `${slot.slotId}:${slot.label}`), _jsxs("span", { className: "truncate px-1 text-[10px] text-muted-foreground", children: [materialLabel, " \u00B7 ", faceCount, " ", faceCount === 1 ? 'face' : 'faces'] })] }), slot.slotId === BLOCK_BODY_SLOT_ID ? (_jsx("span", { className: `${SLOT_TRAILING_ACTION_CLASS} pointer-events-none relative z-10 text-primary`, children: active ? _jsx(Check, { "aria-hidden": "true", className: "h-4 w-4" }) : null })) : (_jsx("button", { className: `${SLOT_TRAILING_ACTION_CLASS} relative z-10 text-muted-foreground transition-colors hover:bg-red-500/15 hover:text-red-300 focus-visible:bg-red-500/15 focus-visible:text-red-300 disabled:cursor-not-allowed disabled:opacity-40 disabled:hover:bg-transparent disabled:hover:text-muted-foreground`, "aria-label": `Delete ${slot.label} slot`, disabled: !editing || readOnly, onClick: () => removeMaterialSlot(slot.slotId), title: slotEditTitle ?? 'Delete material slot and use Body on its faces', type: "button", children: _jsx(Trash2, { "aria-hidden": "true", className: "h-3.5 w-3.5" }) }))] }, slot.slotId));
+                        }) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-4 w-4" }), label: "Move", onClick: move }), _jsx(ActionButton, { className: "border-red-500/40 text-red-200 hover:bg-red-500/15", icon: _jsx(Trash2, { className: "h-4 w-4" }), label: "Delete", onClick: () => {
+                                useScene.getState().deleteNode(node.id);
+                                setViewerSelection({ selectedIds: [] });
+                            } })] }) })] }));
+}

package/dist/block/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { BlockNode } from './schema';
+export declare const blockParametrics: ParametricDescriptor<BlockNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/block/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/block/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,gBAAgB,EAAE,oBAAoB,CAAC,SAAS,CAQ5D,CAAA"}

package/dist/block/parametrics.js

@@ -0,0 +1,9 @@
+export const blockParametrics = {
+    groups: [
+        {
+            label: 'Position',
+            fields: [{ key: 'position', kind: 'vec3' }],
+        },
+    ],
+    customPanel: () => import('./panel'),
+};