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

package/dist/block/geometry.js

@@ -0,0 +1,146 @@
+import { createSurfaceRoleMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
+import { BufferGeometry, Float32BufferAttribute, FrontSide, Group, Mesh, ShapeUtils, Vector2, Vector3, } from 'three';
+import { blockFaceNormal } from './commands';
+import { BLOCK_BODY_SLOT_ID, blockMaterialSlotIds } from './material-slots';
+const SMOOTH_NORMAL_ANGLE_COSINE = Math.cos(Math.PI / 6);
+function projectedPoint(point, normal) {
+    const ax = Math.abs(normal[0]);
+    const ay = Math.abs(normal[1]);
+    const az = Math.abs(normal[2]);
+    if (ax >= ay && ax >= az)
+        return new Vector2(point[1], point[2]);
+    if (ay >= az)
+        return new Vector2(point[0], point[2]);
+    return new Vector2(point[0], point[1]);
+}
+export function triangulateBlockFace(topology, face) {
+    const vertexById = new Map(topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const contour = face.vertexIds
+        .map((id) => vertexById.get(id))
+        .filter((point) => !!point);
+    const normal = blockFaceNormal(topology, face);
+    if (!normal || contour.length !== face.vertexIds.length)
+        return null;
+    const triangleIndices = ShapeUtils.triangulateShape(contour.map((point) => projectedPoint(point, normal)), []);
+    const targetNormal = new Vector3(...normal);
+    const triangles = [];
+    for (const indices of triangleIndices) {
+        const aIndex = indices[0];
+        const bIndex = indices[1];
+        const cIndex = indices[2];
+        if (aIndex === undefined || bIndex === undefined || cIndex === undefined)
+            continue;
+        const a = contour[aIndex];
+        let b = contour[bIndex];
+        let c = contour[cIndex];
+        if (!(a && b && c))
+            continue;
+        const triangleNormal = new Vector3(...b)
+            .sub(new Vector3(...a))
+            .cross(new Vector3(...c).sub(new Vector3(...a)));
+        if (triangleNormal.dot(targetNormal) < 0)
+            [b, c] = [c, b];
+        triangles.push([a, b, c]);
+    }
+    return { triangles, normal };
+}
+export function buildBlockGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const group = new Group();
+    group.name = 'block-geometry';
+    const geometry = new BufferGeometry();
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    const faceRanges = [];
+    const slotIds = blockMaterialSlotIds(node.topology, node.slots, node.slotNames);
+    const materialIndexBySlotId = new Map(slotIds.map((slotId, index) => [slotId, index]));
+    const faceNormals = new Map(node.topology.faces.flatMap((face) => {
+        const normal = blockFaceNormal(node.topology, face);
+        return normal ? [[face.id, normal]] : [];
+    }));
+    const adjacentFaceNormals = new Map();
+    for (const face of node.topology.faces) {
+        const normal = faceNormals.get(face.id);
+        if (!normal)
+            continue;
+        for (const vertexId of face.vertexIds) {
+            const adjacent = adjacentFaceNormals.get(vertexId) ?? [];
+            adjacent.push(normal);
+            adjacentFaceNormals.set(vertexId, adjacent);
+        }
+    }
+    const cornerNormals = new Map();
+    for (const face of node.topology.faces) {
+        const faceNormal = faceNormals.get(face.id);
+        if (!faceNormal)
+            continue;
+        for (const vertexId of face.vertexIds) {
+            const smoothNormal = new Vector3();
+            for (const adjacentNormal of adjacentFaceNormals.get(vertexId) ?? []) {
+                const dot = faceNormal[0] * adjacentNormal[0] +
+                    faceNormal[1] * adjacentNormal[1] +
+                    faceNormal[2] * adjacentNormal[2];
+                if (dot >= SMOOTH_NORMAL_ANGLE_COSINE)
+                    smoothNormal.add(new Vector3(...adjacentNormal));
+            }
+            smoothNormal.normalize();
+            cornerNormals.set(`${face.id}\u0000${vertexId}`, smoothNormal.toArray());
+        }
+    }
+    const vertexIdByPosition = new Map(node.topology.vertices.map((vertex) => [vertex.position, vertex.id]));
+    for (const face of node.topology.faces) {
+        const triangulated = triangulateBlockFace(node.topology, face);
+        if (!triangulated)
+            continue;
+        const start = positions.length / 3;
+        for (const triangle of triangulated.triangles) {
+            for (const point of triangle) {
+                positions.push(...point);
+                const vertexId = vertexIdByPosition.get(point);
+                normals.push(...(vertexId
+                    ? (cornerNormals.get(`${face.id}\u0000${vertexId}`) ?? triangulated.normal)
+                    : triangulated.normal));
+                const uv = projectedPoint(point, triangulated.normal);
+                uvs.push(uv.x, uv.y);
+            }
+        }
+        const count = positions.length / 3 - start;
+        geometry.addGroup(start, count, materialIndexBySlotId.get(face.materialSlot) ?? 0);
+        faceRanges.push({ faceId: face.id, start, count });
+    }
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+    geometry.computeBoundingBox();
+    geometry.computeBoundingSphere();
+    geometry.userData.blockFaces = faceRanges;
+    const bodyMaterialRef = node.slots?.[BLOCK_BODY_SLOT_ID];
+    const roleMaterial = createSurfaceRoleMaterial('wall', colorPreset, FrontSide, sceneTheme);
+    const bodyMaterial = (textures && bodyMaterialRef
+        ? resolveMaterialRef(bodyMaterialRef, ctx?.materials, shading)
+        : null) ?? roleMaterial;
+    const bodyFallbackSlotIds = [];
+    const materials = slotIds.map((slotId) => {
+        const materialRef = node.slots?.[slotId];
+        if (slotId === BLOCK_BODY_SLOT_ID)
+            return bodyMaterial;
+        if (!materialRef) {
+            bodyFallbackSlotIds.push(slotId);
+            return bodyMaterial;
+        }
+        const resolved = textures ? resolveMaterialRef(materialRef, ctx?.materials, shading) : null;
+        if (resolved)
+            return resolved;
+        bodyFallbackSlotIds.push(slotId);
+        return bodyMaterial;
+    });
+    const mesh = new Mesh(geometry, materials);
+    mesh.name = 'block-body';
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.userData.block = true;
+    mesh.userData.slotIds = slotIds;
+    mesh.userData.bodyFallbackSlotIds = bodyFallbackSlotIds;
+    group.add(mesh);
+    return group;
+}

package/dist/block/gesture-wheel.d.ts

@@ -0,0 +1,8 @@
+export declare const BLOCK_WHEEL_OPTIONS: {
+    readonly capture: true;
+    readonly passive: false;
+};
+type BlockGestureWheelEvent = Pick<WheelEvent, 'deltaY' | 'preventDefault' | 'stopImmediatePropagation' | 'stopPropagation'>;
+export declare function consumeBlockGestureWheel(event: BlockGestureWheelEvent): -1 | 0 | 1;
+export {};
+//# sourceMappingURL=gesture-wheel.d.ts.map

package/dist/block/gesture-wheel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gesture-wheel.d.ts","sourceRoot":"","sources":["../../src/block/gesture-wheel.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;CAA6C,CAAA;AAE7E,KAAK,sBAAsB,GAAG,IAAI,CAChC,UAAU,EACV,QAAQ,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,iBAAiB,CAC7E,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAKlF"}

package/dist/block/gesture-wheel.js

@@ -0,0 +1,7 @@
+export const BLOCK_WHEEL_OPTIONS = { capture: true, passive: false };
+export function consumeBlockGestureWheel(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    event.stopImmediatePropagation();
+    return event.deltaY < 0 ? 1 : event.deltaY > 0 ? -1 : 0;
+}

package/dist/block/interaction-sfx.d.ts

@@ -0,0 +1,3 @@
+export type BlockSfxAction = 'tool-select' | 'component-select' | 'drag-start' | 'move-step' | 'rotate-step' | 'resize-step' | 'operation-start' | 'operation-commit' | 'delete' | 'cancel' | 'finish';
+export declare function blockSfx(action: BlockSfxAction): "sfx:grid-snap" | "sfx:item-pick" | "sfx:item-place" | "sfx:item-rotate" | "sfx:resize" | "sfx:structure-build-start" | "sfx:structure-build" | "sfx:structure-delete" | "sfx:menu-click";
+//# sourceMappingURL=interaction-sfx.d.ts.map

package/dist/block/interaction-sfx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction-sfx.d.ts","sourceRoot":"","sources":["../../src/block/interaction-sfx.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,kBAAkB,GAClB,YAAY,GACZ,WAAW,GACX,aAAa,GACb,aAAa,GACb,iBAAiB,GACjB,kBAAkB,GAClB,QAAQ,GACR,QAAQ,GACR,QAAQ,CAAA;AAgBZ,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,6LAE9C"}

package/dist/block/interaction-sfx.js

@@ -0,0 +1,16 @@
+const BLOCK_SFX = {
+    'tool-select': 'sfx:menu-click',
+    'component-select': 'sfx:item-pick',
+    'drag-start': 'sfx:item-pick',
+    'move-step': 'sfx:grid-snap',
+    'rotate-step': 'sfx:item-rotate',
+    'resize-step': 'sfx:resize',
+    'operation-start': 'sfx:structure-build-start',
+    'operation-commit': 'sfx:structure-build',
+    delete: 'sfx:structure-delete',
+    cancel: 'sfx:menu-click',
+    finish: 'sfx:item-place',
+};
+export function blockSfx(action) {
+    return BLOCK_SFX[action];
+}

package/dist/block/last-operation.d.ts

@@ -0,0 +1,48 @@
+import type { AnyNodeId, BlockTopology, SceneApi } from '@pascal-app/core';
+import type { SelectionAffordanceHistoryApi } from '@pascal-app/editor';
+import { type BlockCommand, type BlockCommandResult, type BlockSelection } from './commands';
+type SuccessfulBlockCommandResult = Extract<BlockCommandResult, {
+    ok: true;
+}>;
+export type BlockOperationServices = {
+    historyApi: SelectionAffordanceHistoryApi;
+    readOnly: boolean;
+    sceneApi: Pick<SceneApi, 'get' | 'update'>;
+};
+export type BlockLastOperation = {
+    baseTopology: BlockTopology;
+    command: BlockCommand;
+    historyDepth: number;
+    label: string;
+    nodeId: AnyNodeId;
+    resultSelection: BlockSelection;
+    resultTopology: BlockTopology;
+};
+export type BlockLastOperationReplacement = {
+    ok: true;
+    operation: BlockLastOperation;
+} | {
+    ok: false;
+    error: string;
+};
+export type BlockOperationCommit = {
+    ok: true;
+    changed: false;
+} | {
+    ok: true;
+    changed: true;
+    operation: BlockLastOperation;
+    result: SuccessfulBlockCommandResult;
+} | {
+    ok: false;
+    error: string;
+};
+type RepeatSelection = BlockSelection & {
+    activeId: string | null;
+};
+export declare function recordCommittedBlockOperation(services: BlockOperationServices, nodeId: AnyNodeId, label: string, baseTopology: BlockTopology, command: BlockCommand, result: SuccessfulBlockCommandResult): BlockLastOperation;
+export declare function commitBlockOperation(services: BlockOperationServices, nodeId: AnyNodeId, label: string, baseTopology: BlockTopology, command: BlockCommand): BlockOperationCommit;
+export declare function replaceCommittedBlockOperation(services: BlockOperationServices, operation: BlockLastOperation, command: BlockCommand): BlockLastOperationReplacement;
+export declare function repeatCommittedBlockOperation(services: BlockOperationServices, operation: BlockLastOperation, selection: RepeatSelection): BlockLastOperationReplacement;
+export {};
+//# sourceMappingURL=last-operation.d.ts.map

package/dist/block/last-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"last-operation.d.ts","sourceRoot":"","sources":["../../src/block/last-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAa,aAAa,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACrF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAA;AACvE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAA;AAEnB,KAAK,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,EAAE;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAE7E,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,6BAA6B,CAAA;IACzC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAA;CAC3C,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,EAAE,aAAa,CAAA;IAC3B,OAAO,EAAE,YAAY,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;IACjB,eAAe,EAAE,cAAc,CAAA;IAC/B,cAAc,EAAE,aAAa,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,6BAA6B,GACrC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,kBAAkB,CAAA;CAAE,GAC3C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhC,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,KAAK,CAAA;CAAE,GAC5B;IACE,EAAE,EAAE,IAAI,CAAA;IACR,OAAO,EAAE,IAAI,CAAA;IACb,SAAS,EAAE,kBAAkB,CAAA;IAC7B,MAAM,EAAE,4BAA4B,CAAA;CACrC,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhC,KAAK,eAAe,GAAG,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAsDnE,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,aAAa,EAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,4BAA4B,GACnC,kBAAkB,CAUpB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,aAAa,EAC3B,OAAO,EAAE,YAAY,GACpB,oBAAoB,CAoBtB;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,YAAY,GACpB,6BAA6B,CAkC/B;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,sBAAsB,EAChC,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,eAAe,GACzB,6BAA6B,CAyB/B"}

package/dist/block/last-operation.js

@@ -0,0 +1,120 @@
+import { applyBlockCommand, blockSelectionVertexIds, } from './commands';
+function sameTopology(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function selectionCentroid(topology, selection) {
+    const selectedIds = blockSelectionVertexIds(topology, selection);
+    const points = topology.vertices.filter((vertex) => selectedIds.has(vertex.id));
+    if (points.length === 0)
+        return null;
+    const total = points.reduce((sum, vertex) => vertex.position.map((value, index) => sum[index] + value), [0, 0, 0]);
+    return total.map((value) => value / points.length);
+}
+function commandForRepeat(command, topology, selection) {
+    const activeId = selection.activeId ?? selection.ids.at(-1);
+    switch (command.type) {
+        case 'translate-components':
+            return selection.ids.length > 0 ? { ...command, selection } : null;
+        case 'rotate-components': {
+            const pivot = selectionCentroid(topology, selection);
+            return pivot ? { ...command, selection, pivot } : null;
+        }
+        case 'scale-components': {
+            const pivot = selectionCentroid(topology, selection);
+            return pivot ? { ...command, selection, pivot } : null;
+        }
+        case 'extrude-faces':
+            return selection.mode === 'face' && selection.ids.length > 0
+                ? { ...command, faceIds: selection.ids }
+                : null;
+        case 'inset-faces':
+            return selection.mode === 'face' && selection.ids.length > 0
+                ? { ...command, faceIds: selection.ids }
+                : null;
+        case 'bevel-edges':
+            return selection.mode === 'edge' && selection.ids.length > 0
+                ? { ...command, edgeIds: selection.ids }
+                : null;
+        case 'loop-cut':
+            return selection.mode === 'edge' && activeId ? { ...command, edgeId: activeId } : null;
+        default:
+            return null;
+    }
+}
+export function recordCommittedBlockOperation(services, nodeId, label, baseTopology, command, result) {
+    return {
+        baseTopology,
+        command,
+        historyDepth: services.historyApi.depth(),
+        label,
+        nodeId,
+        resultSelection: result.selection,
+        resultTopology: result.topology,
+    };
+}
+export function commitBlockOperation(services, nodeId, label, baseTopology, command) {
+    if (services.readOnly)
+        return { ok: false, error: 'Scene is read-only' };
+    const result = applyBlockCommand(baseTopology, command);
+    if (!result.ok)
+        return result;
+    if (sameTopology(baseTopology, result.topology))
+        return { ok: true, changed: false };
+    services.sceneApi.update(nodeId, { topology: result.topology });
+    return {
+        ok: true,
+        changed: true,
+        operation: recordCommittedBlockOperation(services, nodeId, label, baseTopology, command, result),
+        result,
+    };
+}
+export function replaceCommittedBlockOperation(services, operation, command) {
+    if (services.readOnly)
+        return { ok: false, error: 'Scene is read-only' };
+    const current = services.sceneApi.get(operation.nodeId);
+    if (current?.type !== 'block' || !sameTopology(current.topology, operation.resultTopology)) {
+        return { ok: false, error: 'The last operation is no longer the latest scene change' };
+    }
+    if (services.historyApi.depth() !== operation.historyDepth) {
+        return { ok: false, error: 'Scene history changed after the last operation' };
+    }
+    const result = applyBlockCommand(operation.baseTopology, command);
+    if (!result.ok)
+        return result;
+    const restored = services.historyApi.replaceLatest(operation.historyDepth, () => {
+        const baseline = services.sceneApi.get(operation.nodeId);
+        if (baseline?.type !== 'block' || !sameTopology(baseline.topology, operation.baseTopology)) {
+            return false;
+        }
+        services.sceneApi.update(operation.nodeId, { topology: result.topology });
+        return true;
+    });
+    if (!restored)
+        return { ok: false, error: 'Could not restore the operation baseline' };
+    return {
+        ok: true,
+        operation: recordCommittedBlockOperation(services, operation.nodeId, operation.label, operation.baseTopology, command, result),
+    };
+}
+export function repeatCommittedBlockOperation(services, operation, selection) {
+    if (services.readOnly)
+        return { ok: false, error: 'Scene is read-only' };
+    const current = services.sceneApi.get(operation.nodeId);
+    if (current?.type !== 'block' || !sameTopology(current.topology, operation.resultTopology)) {
+        return { ok: false, error: 'The last operation is no longer the latest scene change' };
+    }
+    if (services.historyApi.depth() !== operation.historyDepth) {
+        return { ok: false, error: 'Scene history changed after the last operation' };
+    }
+    const command = commandForRepeat(operation.command, current.topology, selection);
+    if (!command)
+        return { ok: false, error: 'The current selection cannot repeat this operation' };
+    const result = applyBlockCommand(current.topology, command);
+    if (!result.ok)
+        return result;
+    services.sceneApi.update(operation.nodeId, { topology: result.topology });
+    return {
+        ok: true,
+        operation: recordCommittedBlockOperation(services, operation.nodeId, operation.label, current.topology, command, result),
+    };
+}

package/dist/block/loop-cut-interaction.d.ts

@@ -0,0 +1,5 @@
+export type LoopCutInteractionStage = 'choosing-ring' | 'sliding';
+export type LoopCutPointerAction = 'begin-slide' | 'commit-current' | 'commit-centered' | 'cancel';
+export declare function resolveLoopCutPointerAction(stage: LoopCutInteractionStage, button: number): LoopCutPointerAction | null;
+export declare function resolveLoopCutSlideFactor(cuts: number, requestedFactor: number): number;
+//# sourceMappingURL=loop-cut-interaction.d.ts.map

package/dist/block/loop-cut-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-cut-interaction.d.ts","sourceRoot":"","sources":["../../src/block/loop-cut-interaction.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,eAAe,GAAG,SAAS,CAAA;AAEjE,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,QAAQ,CAAA;AAElG,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,uBAAuB,EAC9B,MAAM,EAAE,MAAM,GACb,oBAAoB,GAAG,IAAI,CAO7B;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAEvF"}

package/dist/block/loop-cut-interaction.js

@@ -0,0 +1,13 @@
+export function resolveLoopCutPointerAction(stage, button) {
+    if (stage === 'choosing-ring') {
+        if (button === 0)
+            return 'begin-slide';
+        return button === 2 ? 'cancel' : null;
+    }
+    if (button === 0)
+        return 'commit-current';
+    return button === 2 ? 'commit-centered' : null;
+}
+export function resolveLoopCutSlideFactor(cuts, requestedFactor) {
+    return cuts === 1 ? requestedFactor : 0.5;
+}

package/dist/block/material-slots.d.ts

@@ -0,0 +1,61 @@
+import type { BlockTopology, MaterialRef } from '@pascal-app/core';
+export declare const BLOCK_BODY_SLOT_ID = "body";
+export type BlockMaterialSlots = Record<string, MaterialRef> | undefined;
+export type BlockMaterialSlotNames = Record<string, string> | undefined;
+export type BlockMaterialSelection = {
+    kind: 'empty';
+    activeSlotId: null;
+} | {
+    kind: 'single';
+    activeSlotId: string;
+    slotId: string;
+} | {
+    kind: 'mixed';
+    activeSlotId: string | null;
+};
+export type BlockMaterialAssignment = {
+    kind: 'slot';
+    slotId: string;
+};
+export type BlockMaterialAssignmentResult = {
+    topology: BlockTopology;
+    slots: BlockMaterialSlots;
+    slotId: string;
+    changed: boolean;
+};
+export type BlockMaterialSlotRemovalResult = {
+    topology: BlockTopology;
+    slots: BlockMaterialSlots;
+    slotNames: BlockMaterialSlotNames;
+    fallbackSlotId: string;
+    changed: boolean;
+};
+export type BlockMaterialSlotUpdateResult = {
+    slots: BlockMaterialSlots;
+    changed: boolean;
+};
+export type BlockMaterialSlotCreationResult = {
+    slotId: string;
+    slotNames: Record<string, string>;
+};
+export type BlockAssignedMaterialSlotCreationResult = (BlockMaterialSlotCreationResult & {
+    topology: BlockTopology;
+    slots: BlockMaterialSlots;
+    changed: true;
+}) | {
+    topology: BlockTopology;
+    slots: BlockMaterialSlots;
+    slotId: null;
+    slotNames: BlockMaterialSlotNames;
+    changed: false;
+};
+export declare function blockMaterialSlotIds(topology: BlockTopology, slots: BlockMaterialSlots, slotNames?: BlockMaterialSlotNames): string[];
+export declare function unpaintedBlockMaterialSlotIds(topology: BlockTopology, slots: BlockMaterialSlots, slotNames?: BlockMaterialSlotNames): string[];
+export declare function createBlockMaterialSlot(topology: BlockTopology, slots: BlockMaterialSlots, slotNames: BlockMaterialSlotNames): BlockMaterialSlotCreationResult;
+export declare function createAssignedBlockMaterialSlot(topology: BlockTopology, slots: BlockMaterialSlots, slotNames: BlockMaterialSlotNames, selectedFaceIds: readonly string[], materialRef: MaterialRef): BlockAssignedMaterialSlotCreationResult;
+export declare function renameBlockMaterialSlot(topology: BlockTopology, slots: BlockMaterialSlots, slotNames: BlockMaterialSlotNames, slotId: string, name: string): BlockMaterialSlotNames;
+export declare function setBlockMaterialSlot(slots: BlockMaterialSlots, slotId: string, materialRef: MaterialRef | undefined): BlockMaterialSlotUpdateResult;
+export declare function blockMaterialSelection(topology: BlockTopology, selectedFaceIds: readonly string[], activeFaceId: string | null): BlockMaterialSelection;
+export declare function removeBlockMaterialSlot(topology: BlockTopology, slots: BlockMaterialSlots, slotId: string, slotNames?: BlockMaterialSlotNames): BlockMaterialSlotRemovalResult;
+export declare function assignBlockMaterial(topology: BlockTopology, slots: BlockMaterialSlots, selectedFaceIds: readonly string[], assignment: BlockMaterialAssignment, slotNames?: BlockMaterialSlotNames): BlockMaterialAssignmentResult;
+//# sourceMappingURL=material-slots.d.ts.map

package/dist/block/material-slots.d.ts.map

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

package/dist/block/material-slots.js

@@ -0,0 +1,131 @@
+export const BLOCK_BODY_SLOT_ID = 'body';
+export function blockMaterialSlotIds(topology, slots, slotNames) {
+    const slotIds = new Set([BLOCK_BODY_SLOT_ID]);
+    for (const slotId of Object.keys(slotNames ?? {}))
+        slotIds.add(slotId);
+    for (const slotId of Object.keys(slots ?? {}))
+        slotIds.add(slotId);
+    for (const face of topology.faces)
+        slotIds.add(face.materialSlot);
+    return [...slotIds];
+}
+export function unpaintedBlockMaterialSlotIds(topology, slots, slotNames) {
+    return blockMaterialSlotIds(topology, slots, slotNames).filter((slotId) => slotId !== BLOCK_BODY_SLOT_ID && !slots?.[slotId]);
+}
+export function createBlockMaterialSlot(topology, slots, slotNames) {
+    const used = new Set(blockMaterialSlotIds(topology, slots, slotNames));
+    let index = 1;
+    while (used.has(`slot-${index}`))
+        index += 1;
+    const slotId = `slot-${index}`;
+    return {
+        slotId,
+        slotNames: { ...slotNames, [slotId]: `Slot ${index}` },
+    };
+}
+export function createAssignedBlockMaterialSlot(topology, slots, slotNames, selectedFaceIds, materialRef) {
+    const selected = new Set(selectedFaceIds);
+    if (!topology.faces.some((face) => selected.has(face.id))) {
+        return { topology, slots, slotId: null, slotNames, changed: false };
+    }
+    const created = createBlockMaterialSlot(topology, slots, slotNames);
+    const assigned = assignBlockMaterial(topology, slots, selectedFaceIds, { kind: 'slot', slotId: created.slotId }, created.slotNames);
+    const bound = setBlockMaterialSlot(assigned.slots, created.slotId, materialRef);
+    return {
+        topology: assigned.topology,
+        slots: bound.slots,
+        slotId: created.slotId,
+        slotNames: created.slotNames,
+        changed: true,
+    };
+}
+export function renameBlockMaterialSlot(topology, slots, slotNames, slotId, name) {
+    const nextName = name.trim();
+    if (!nextName ||
+        !blockMaterialSlotIds(topology, slots, slotNames).includes(slotId) ||
+        slotNames?.[slotId] === nextName) {
+        return slotNames;
+    }
+    return { ...slotNames, [slotId]: nextName };
+}
+export function setBlockMaterialSlot(slots, slotId, materialRef) {
+    if (materialRef) {
+        if (slots?.[slotId] === materialRef)
+            return { slots, changed: false };
+        return { slots: { ...slots, [slotId]: materialRef }, changed: true };
+    }
+    if (!Object.hasOwn(slots ?? {}, slotId))
+        return { slots, changed: false };
+    const retainedEntries = Object.entries(slots ?? {}).filter(([candidate]) => candidate !== slotId);
+    return {
+        slots: retainedEntries.length > 0 ? Object.fromEntries(retainedEntries) : undefined,
+        changed: true,
+    };
+}
+export function blockMaterialSelection(topology, selectedFaceIds, activeFaceId) {
+    const selected = new Set(selectedFaceIds);
+    const selectedFaces = topology.faces.filter((face) => selected.has(face.id));
+    const firstSelectedFace = selectedFaces[0];
+    if (!firstSelectedFace)
+        return { kind: 'empty', activeSlotId: null };
+    const firstSlotId = firstSelectedFace.materialSlot;
+    const activeSlotId = topology.faces.find((face) => face.id === activeFaceId && selected.has(face.id))
+        ?.materialSlot ?? null;
+    if (selectedFaces.every((face) => face.materialSlot === firstSlotId)) {
+        return {
+            kind: 'single',
+            slotId: firstSlotId,
+            activeSlotId: activeSlotId ?? firstSlotId,
+        };
+    }
+    return { kind: 'mixed', activeSlotId };
+}
+export function removeBlockMaterialSlot(topology, slots, slotId, slotNames) {
+    const slotIds = blockMaterialSlotIds(topology, slots, slotNames);
+    const fallbackSlotId = slotIds[0] ?? BLOCK_BODY_SLOT_ID;
+    if (slotId === fallbackSlotId || !slotIds.includes(slotId)) {
+        return { topology, slots, slotNames, fallbackSlotId, changed: false };
+    }
+    const remapsFaces = topology.faces.some((face) => face.materialSlot === slotId);
+    const removesBinding = Object.hasOwn(slots ?? {}, slotId);
+    const removesName = Object.hasOwn(slotNames ?? {}, slotId);
+    if (!(remapsFaces || removesBinding || removesName)) {
+        return { topology, slots, slotNames, fallbackSlotId, changed: false };
+    }
+    const retainedEntries = Object.entries(slots ?? {}).filter(([candidate]) => candidate !== slotId);
+    const retainedNames = Object.entries(slotNames ?? {}).filter(([candidate]) => candidate !== slotId);
+    return {
+        topology: remapsFaces
+            ? {
+                ...topology,
+                faces: topology.faces.map((face) => face.materialSlot === slotId ? { ...face, materialSlot: fallbackSlotId } : face),
+            }
+            : topology,
+        slots: retainedEntries.length > 0 ? Object.fromEntries(retainedEntries) : undefined,
+        slotNames: retainedNames.length > 0 ? Object.fromEntries(retainedNames) : undefined,
+        fallbackSlotId,
+        changed: true,
+    };
+}
+export function assignBlockMaterial(topology, slots, selectedFaceIds, assignment, slotNames) {
+    const selected = new Set(selectedFaceIds);
+    const hasSelectedFace = topology.faces.some((face) => selected.has(face.id));
+    const slotId = assignment.slotId;
+    if (!blockMaterialSlotIds(topology, slots, slotNames).includes(slotId)) {
+        return { topology, slots, slotId, changed: false };
+    }
+    if (!hasSelectedFace)
+        return { topology, slots, slotId, changed: false };
+    if (topology.faces.every((face) => !selected.has(face.id) || face.materialSlot === slotId)) {
+        return { topology, slots, slotId, changed: false };
+    }
+    return {
+        topology: {
+            ...topology,
+            faces: topology.faces.map((face) => selected.has(face.id) ? { ...face, materialSlot: slotId } : face),
+        },
+        slots,
+        slotId,
+        changed: true,
+    };
+}

package/dist/block/modal-face-operation.d.ts

@@ -0,0 +1,13 @@
+import type { BlockCommand } from './commands';
+import { type BlockModalFeedbackMode } from './modal-transform';
+export type BlockModalFaceOperation = 'extrude' | 'inset';
+export type BlockExtrudeAxis = 'normal' | 'x' | 'y' | 'z';
+type BlockPointerClientPosition = {
+    x: number;
+    y: number;
+};
+export declare function blockFaceOperationValueFromPointer(operation: BlockModalFaceOperation, startPointer: BlockPointerClientPosition, currentPointer: BlockPointerClientPosition, pivot: BlockPointerClientPosition, topologyExtent: number, projectedExtentPixels: number, extrusionDirection?: BlockPointerClientPosition | null): number;
+export declare function blockFaceOperationCommand(operation: BlockModalFaceOperation, faceIds: string[], value: number, extrudeAxis?: BlockExtrudeAxis): BlockCommand;
+export declare function blockModalFaceOperationStatus(operation: BlockModalFaceOperation, value: string, feedbackMode?: BlockModalFeedbackMode, extrudeAxis?: BlockExtrudeAxis): string;
+export {};
+//# sourceMappingURL=modal-face-operation.d.ts.map

package/dist/block/modal-face-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-face-operation.d.ts","sourceRoot":"","sources":["../../src/block/modal-face-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,KAAK,sBAAsB,EAA2B,MAAM,mBAAmB,CAAA;AAExF,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,OAAO,CAAA;AACzD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAEzD,KAAK,0BAA0B,GAAG;IAChC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAED,wBAAgB,kCAAkC,CAChD,SAAS,EAAE,uBAAuB,EAClC,YAAY,EAAE,0BAA0B,EACxC,cAAc,EAAE,0BAA0B,EAC1C,KAAK,EAAE,0BAA0B,EACjC,cAAc,EAAE,MAAM,EACtB,qBAAqB,EAAE,MAAM,EAC7B,kBAAkB,CAAC,EAAE,0BAA0B,GAAG,IAAI,GACrD,MAAM,CAuBR;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,gBAA2B,GACvC,YAAY,CASd;AAED,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,uBAAuB,EAClC,KAAK,EAAE,MAAM,EACb,YAAY,GAAE,sBAA+B,EAC7C,WAAW,GAAE,gBAA2B,GACvC,MAAM,CAQR"}

package/dist/block/modal-face-operation.js

@@ -0,0 +1,40 @@
+import { blockModalFeedbackLabel } from './modal-transform';
+export function blockFaceOperationValueFromPointer(operation, startPointer, currentPointer, pivot, topologyExtent, projectedExtentPixels, extrusionDirection) {
+    const safeProjectedExtent = Math.max(1, Math.abs(projectedExtentPixels));
+    if (operation === 'extrude') {
+        const directionLength = extrusionDirection
+            ? Math.hypot(extrusionDirection.x, extrusionDirection.y)
+            : 0;
+        if (extrusionDirection && directionLength > 1e-6) {
+            const pointerTravel = ((currentPointer.x - startPointer.x) * extrusionDirection.x +
+                (currentPointer.y - startPointer.y) * extrusionDirection.y) /
+                directionLength;
+            return (pointerTravel / safeProjectedExtent) * topologyExtent;
+        }
+        return (((currentPointer.x - startPointer.x - (currentPointer.y - startPointer.y)) /
+            safeProjectedExtent) *
+            topologyExtent);
+    }
+    const startDistance = Math.hypot(startPointer.x - pivot.x, startPointer.y - pivot.y);
+    const currentDistance = Math.hypot(currentPointer.x - pivot.x, currentPointer.y - pivot.y);
+    const inwardTravel = startDistance - currentDistance;
+    return Math.min(0.95, Math.max(0, inwardTravel / safeProjectedExtent));
+}
+export function blockFaceOperationCommand(operation, faceIds, value, extrudeAxis = 'normal') {
+    return operation === 'extrude'
+        ? {
+            type: 'extrude-faces',
+            faceIds,
+            distance: value,
+            ...(extrudeAxis === 'normal' ? {} : { axis: extrudeAxis }),
+        }
+        : { type: 'inset-faces', faceIds, amount: value, depth: 0 };
+}
+export function blockModalFaceOperationStatus(operation, value, feedbackMode = 'free', extrudeAxis = 'normal') {
+    const label = operation === 'extrude' ? 'Extrude' : 'Inset';
+    const unit = operation === 'extrude' ? 'm' : 'ratio';
+    const axis = operation === 'extrude' && extrudeAxis !== 'normal'
+        ? ` · ${extrudeAxis.toUpperCase()} axis`
+        : '';
+    return `${label} · ${value} ${unit} · ${blockModalFeedbackLabel(feedbackMode)}${axis} · type value · click applies · Esc cancels`;
+}