@pascal-app/nodes 1.0.1 → 1.0.4

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/block/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,IAAI,aAAa,EAE/B,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa;UAMtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;EAalD;AAYD,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA2F5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/block/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,IAAI,aAAa,EAG/B,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AASzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAmBpC,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa;UAMtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;YACtB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;EAalD;AAYD,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA8F5D,CAAA"}

package/dist/block/definition.js

@@ -1,4 +1,5 @@
-import { createBoxBlockTopology, } from '@pascal-app/core';
+import { blockSlots, createBoxBlockTopology, } from '@pascal-app/core';
+import { perNodeGeometryBatchable } from '../shared/node-batch/batchable';
 import { blockContextualHelp } from './contextual-help';
 import { blockFaceHost } from './face-host';
 import { buildBlockFloorplan } from './floorplan';
@@ -6,7 +7,21 @@ import { buildBlockGeometry } from './geometry';
 import { blockPaint } from './paint';
 import { blockParametrics } from './parametrics';
 import { BlockNode } from './schema';
-import { blockSlots } from './slots';
+import { blockSurfaceProvider } from './surface';
+/** Bottom within this of the floor (and top above it): the block stands on the floor. */
+const BLOCK_ON_FLOOR_MAX_BOTTOM = 0.1;
+const BLOCK_ON_FLOOR_MIN_TOP = 0.01;
+/**
+ * Floor collision is for blocks standing on the floor. Soffits, vaults,
+ * gutters and mantels hang above floor placements, and foundation pads sit
+ * under the floor, so neither blocks furniture nor gets refused when moved.
+ */
+function blockRestsOnFloor(node) {
+    const { size, center } = blockBounds(node);
+    const bottom = node.position[1] + center[1] - size[1] / 2;
+    const top = node.position[1] + center[1] + size[1] / 2;
+    return bottom <= BLOCK_ON_FLOOR_MAX_BOTTOM && top > BLOCK_ON_FLOOR_MIN_TOP;
+}
 export function blockBounds(node) {
     const xs = node.topology.vertices.map((vertex) => vertex.position[0]);
     const ys = node.topology.vertices.map((vertex) => vertex.position[1]);
@@ -64,8 +79,10 @@ export const blockDefinition = {
         slotNames: { body: 'Body' },
     }),
     capabilities: {
+        batchable: perNodeGeometryBatchable,
         selectable: { hitVolume: 'bbox' },
         surfaces: {
+            hosting: blockSurfaceProvider,
             top: {
                 height: (rawNode) => {
                     const node = rawNode;
@@ -76,7 +93,7 @@ export const blockDefinition = {
             sides: { faces: 'all' },
         },
         movable: { axes: ['x', 'z'], gridSnap: true },
-        duplicable: true,
+        duplicable: { subtree: true },
         deletable: true,
         dragBounds: (rawNode) => blockBounds(rawNode),
         floorPlaced: {
@@ -89,7 +106,7 @@ export const blockDefinition = {
                     rotation: [0, node.rotation, 0],
                 };
             },
-            collides: true,
+            collides: (rawNode) => blockRestsOnFloor(rawNode),
         },
         paint: blockPaint,
         slots: (rawNode) => blockSlots(rawNode),
@@ -100,6 +117,7 @@ export const blockDefinition = {
         cascadeDelete: 'descendants',
     },
     geometry: buildBlockGeometry,
+    geometryChildTypes: [],
     geometryKey: (node) => JSON.stringify([node.topology, node.slots]),
     floorplan: buildBlockFloorplan,
     parametrics: blockParametrics,

package/dist/block/face-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"face-host.d.ts","sourceRoot":"","sources":["../../src/block/face-host.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EAGxB,MAAM,kBAAkB,CAAA;AAqLzB,eAAO,MAAM,aAAa,EAAE,kBAAkB,CAAC,SAAS,CA+BvD,CAAA"}
+{"version":3,"file":"face-host.d.ts","sourceRoot":"","sources":["../../src/block/face-host.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EAIxB,MAAM,kBAAkB,CAAA;AAgMzB,eAAO,MAAM,aAAa,EAAE,kBAAkB,CAAC,SAAS,CAqCvD,CAAA"}

package/dist/block/face-host.js

@@ -1,5 +1,6 @@
-import { getBlockFaceFrame, } from '@pascal-app/core';
+import { getBlockFaceFrame, surfaceRegionContainsPoint, } from '@pascal-app/core';
 import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { blockTopSurfaces } from './surface';
 const BLOCK_HORIZONTAL_NORMAL_MIN_Y = 0.95;
 const BLOCK_VERTICAL_NORMAL_MAX_Y = 0.05;
 const BLOCK_FLOOR_ROTATION_X = Math.PI / 2;
@@ -73,6 +74,7 @@ function resolveBlockFaceTargetForFace(args, faceId, options = {}) {
     if (!face)
         return null;
     const vertices = new Map(args.host.topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const polygon = [];
     let minU = Number.POSITIVE_INFINITY;
     let maxU = Number.NEGATIVE_INFINITY;
     let minV = Number.POSITIVE_INFINITY;
@@ -86,6 +88,7 @@ function resolveBlockFaceTargetForFace(args, faceId, options = {}) {
         const dz = point[2] - frame.origin[2];
         const pointU = dx * xAxis.x + dy * xAxis.y + dz * xAxis.z;
         const pointV = dx * yAxis.x + dy * yAxis.y + dz * yAxis.z;
+        polygon.push([pointU, pointV]);
         minU = Math.min(minU, pointU);
         maxU = Math.max(maxU, pointU);
         minV = Math.min(minV, pointV);
@@ -103,6 +106,12 @@ function resolveBlockFaceTargetForFace(args, faceId, options = {}) {
         : clampBlockFacePosition(snappedPosition, faceBounds, [width, height]);
     if (!facePosition)
         return null;
+    if (!attachTo &&
+        !surfaceRegionContainsPoint({ kind: 'polygon', points: polygon }, [
+            facePosition[0],
+            facePosition[1],
+        ]))
+        return null;
     const [u, v] = facePosition;
     const normalOffset = attachTo === 'ceiling' && !args.asset.recessed ? args.rawDimensions[1] : 0;
     const position = [u, v, normalOffset];
@@ -173,6 +182,14 @@ export const blockFaceHost = {
         if (!item.blockFaceId)
             return false;
         const frame = getBlockFaceFrame(host.topology, item.blockFaceId);
-        return !!(frame && blockFaceAcceptsAttachment(frame.normal[1], asset.attachTo));
+        if (!frame || !blockFaceAcceptsAttachment(frame.normal[1], asset.attachTo))
+            return false;
+        if (asset.attachTo)
+            return true;
+        const surface = blockTopSurfaces(host).find((surface) => surface.id === item.blockFaceId);
+        const point = new Vector3(...frame.origin)
+            .addScaledVector(new Vector3(...frame.xAxis), item.position[0])
+            .addScaledVector(new Vector3(...frame.yAxis), item.position[1]);
+        return !!surface && surfaceRegionContainsPoint(surface.region, [point.x, point.z]);
     },
 };

package/dist/block/floorplan.d.ts

@@ -1,3 +1,13 @@
-import type { BlockNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import { type BlockNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+/**
+ * The plan cut: a floor plan is the storey sliced 4 ft above the floor and
+ * looked at from above. A block standing wholly ABOVE that line — fascia and
+ * rake boards, a gable ornament, a dormer, a ceiling fan — is overhead trim a
+ * drafted sheet leaves off (otherwise blocks modelled as roof trim filled the
+ * roof footprint plus its overhang over every room). Level-local metres.
+ */
+export declare const PLAN_CUT_HEIGHT = 1.2;
+/** True when the block's lowest vertex stands above the plan cut. */
+export declare function isOverheadBlock(node: Pick<BlockNode, 'position' | 'topology'>): boolean;
 export declare function buildBlockFloorplan(node: BlockNode, ctx?: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/block/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAuBzB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,GACpB,iBAAiB,GAAG,IAAI,CAqB1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/block/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAuElC,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC,GAAG,OAAO,CAKvF;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,GACpB,iBAAiB,GAAG,IAAI,CA0B1B"}

package/dist/block/floorplan.js

@@ -1,3 +1,14 @@
+import { getBlockFaceNormal, pointInPolygon2D, unionPolygons, } from '@pascal-app/core';
+import { readFloorplanContext } from '@pascal-app/editor';
+/**
+ * The plan cut: a floor plan is the storey sliced 4 ft above the floor and
+ * looked at from above. A block standing wholly ABOVE that line — fascia and
+ * rake boards, a gable ornament, a dormer, a ceiling fan — is overhead trim a
+ * drafted sheet leaves off (otherwise blocks modelled as roof trim filled the
+ * roof footprint plus its overhang over every room). Level-local metres.
+ */
+export const PLAN_CUT_HEIGHT = 1.2;
+const VERTICAL_FACE_MAX_NORMAL_Y = 1e-3;
 function cross(origin, a, b) {
     return (a[0] - origin[0]) * (b[1] - origin[1]) - (a[1] - origin[1]) * (b[0] - origin[0]);
 }
@@ -20,24 +31,81 @@ function convexHull(points) {
     }
     return [...lower.slice(0, -1), ...upper.slice(0, -1)];
 }
+const planRingsByTopology = new WeakMap();
+/**
+ * The block's plan footprint: the union of every non-vertical face projected
+ * onto the level, so L-shapes keep their notch, rings keep their opening and
+ * separate parts stay apart. A topology with no such faces falls back to the
+ * convex hull of its vertices. Cached per topology: selection and hover
+ * rebuild the plan without re-running the union.
+ */
+function blockPlanRings(topology) {
+    const cached = planRingsByTopology.get(topology);
+    if (cached)
+        return cached;
+    const vertexById = new Map(topology.vertices.map((vertex) => [vertex.id, vertex.position]));
+    const projected = [];
+    for (const face of topology.faces) {
+        const normal = getBlockFaceNormal(topology, face, vertexById);
+        if (!normal || Math.abs(normal[1]) <= VERTICAL_FACE_MAX_NORMAL_Y)
+            continue;
+        const ring = face.vertexIds.flatMap((id) => {
+            const position = vertexById.get(id);
+            return position ? [[position[0], position[2]]] : [];
+        });
+        if (ring.length === face.vertexIds.length)
+            projected.push(ring);
+    }
+    let rings = unionPolygons(projected);
+    if (rings.length === 0) {
+        const hull = convexHull(topology.vertices.map((v) => [v.position[0], v.position[2]]));
+        rings = hull.length >= 3 ? [hull] : [];
+    }
+    planRingsByTopology.set(topology, rings);
+    return rings;
+}
+/** A ring inside another is a hole (or an island in one): draw all rings as one evenodd path. */
+function hasNestedRing(rings) {
+    return rings.some((ring, index) => rings.some((other, otherIndex) => otherIndex !== index && pointInPolygon2D(ring[0], other, { includeBoundary: false })));
+}
+function ringPath(rings) {
+    return rings.map((ring) => `M${ring.map(([x, y]) => `${x} ${y}`).join('L')}Z`).join('');
+}
+/** True when the block's lowest vertex stands above the plan cut. */
+export function isOverheadBlock(node) {
+    let minY = Number.POSITIVE_INFINITY;
+    for (const vertex of node.topology.vertices)
+        minY = Math.min(minY, vertex.position[1]);
+    if (!Number.isFinite(minY))
+        return false;
+    return node.position[1] + minY > PLAN_CUT_HEIGHT;
+}
 export function buildBlockFloorplan(node, ctx) {
-    const points = convexHull(node.topology.vertices.map((vertex) => [vertex.position[0], vertex.position[2]]));
-    if (points.length < 3)
+    const rings = blockPlanRings(node.topology);
+    if (rings.length === 0)
         return null;
     const selected = ctx?.viewState?.selected ?? false;
+    const drafting = ctx ? readFloorplanContext(ctx).drafting : false;
+    // Overhead trim is not on a drafted sheet at all.
+    if (drafting && isOverheadBlock(node))
+        return null;
+    const style = {
+        // on a sheet a floor-standing block is an outline in plan ink, like a wall
+        fill: drafting ? 'none' : selected ? '#fed7aa' : '#cbd5e1',
+        fillOpacity: drafting ? 1 : selected ? 0.55 : 0.72,
+        stroke: drafting
+            ? '#111827'
+            : selected
+                ? (ctx?.viewState?.palette?.selectedStroke ?? '#f97316')
+                : '#475569',
+        strokeWidth: selected ? 0.03 : 0.018,
+        pointerEvents: 'all',
+    };
     return {
         kind: 'group',
         transform: { translate: [node.position[0], node.position[2]], rotate: -node.rotation },
-        children: [
-            {
-                kind: 'polygon',
-                points,
-                fill: selected ? '#fed7aa' : '#cbd5e1',
-                fillOpacity: selected ? 0.55 : 0.72,
-                stroke: selected ? (ctx?.viewState?.palette?.selectedStroke ?? '#f97316') : '#475569',
-                strokeWidth: selected ? 0.03 : 0.018,
-                pointerEvents: 'all',
-            },
-        ],
+        children: hasNestedRing(rings)
+            ? [{ kind: 'path', d: ringPath(rings), fillRule: 'evenodd', ...style }]
+            : rings.map((points) => ({ kind: 'polygon', points, ...style })),
     };
 }

package/dist/block/geometry.d.ts

@@ -1,8 +1,8 @@
-import type { BlockFace, BlockNode, BlockTopology, GeometryContext } from '@pascal-app/core';
+import { type BlockFace, type BlockNode, type BlockTopology, type GeometryContext } from '@pascal-app/core';
 import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
 import { Group } from 'three';
 type Point = [number, number, number];
-export declare function triangulateBlockFace(topology: BlockTopology, face: BlockFace): {
+export declare function triangulateBlockFace(topology: BlockTopology, face: BlockFace, vertexById?: Map<string, Point>): {
     triangles: [Point, Point, Point][];
     normal: Point;
 } | null;

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/block/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC5F,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAId,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAYrC,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,SAAS,GACd;IAAE,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CA8B9D;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,EACxC,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CAwGP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/block/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,aAAa,EAElB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,KAAK,EAKN,MAAM,OAAO,CAAA;AAEd,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAYrC,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,SAAS,EACf,UAAU,GAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAE5B,GACA;IAAE,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,GAAG,IAAI,CA6B9D;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,EACxC,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA4HP"}

package/dist/block/geometry.js

@@ -1,7 +1,6 @@
+import { BLOCK_BODY_SLOT_ID, blockMaterialSlotIds, getBlockFaceFrame, getBlockFaceNormal, } from '@pascal-app/core';
 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]);
@@ -13,12 +12,11 @@ function projectedPoint(point, normal) {
         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]));
+export function triangulateBlockFace(topology, face, 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);
+    const normal = getBlockFaceNormal(topology, face, vertexById);
     if (!normal || contour.length !== face.vertexIds.length)
         return null;
     const triangleIndices = ShapeUtils.triangulateShape(contour.map((point) => projectedPoint(point, normal)), []);
@@ -53,9 +51,10 @@ export function buildBlockGeometry(node, ctx, shading = 'rendered', textures = t
     const uvs = [];
     const faceRanges = [];
     const slotIds = blockMaterialSlotIds(node.topology, node.slots, node.slotNames);
-    const materialIndexBySlotId = new Map(slotIds.map((slotId, index) => [slotId, index]));
+    // One id map for the whole build: a per-face map made every rebuild O(faces × vertices).
+    const vertexById = new Map(node.topology.vertices.map((vertex) => [vertex.id, vertex.position]));
     const faceNormals = new Map(node.topology.faces.flatMap((face) => {
-        const normal = blockFaceNormal(node.topology, face);
+        const normal = getBlockFaceNormal(node.topology, face, vertexById);
         return normal ? [[face.id, normal]] : [];
     }));
     const adjacentFaceNormals = new Map();
@@ -88,25 +87,40 @@ export function buildBlockGeometry(node, ctx, shading = 'rendered', textures = t
         }
     }
     const vertexIdByPosition = new Map(node.topology.vertices.map((vertex) => [vertex.position, vertex.id]));
+    // Faces are laid out slot by slot so each material slot is one draw group; the
+    // per-face ranges stay contiguous for picking and paint.
+    const facesBySlot = new Map(slotIds.map((slotId) => [slotId, []]));
     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);
+        ;
+        (facesBySlot.get(face.materialSlot) ?? facesBySlot.get(slotIds[0]))?.push(face);
+    }
+    for (const [materialIndex, slotId] of slotIds.entries()) {
+        const slotStart = positions.length / 3;
+        for (const face of facesBySlot.get(slotId) ?? []) {
+            const triangulated = triangulateBlockFace(node.topology, face, vertexById);
+            // UVs in metres along the face's own frame (level U, up-slope V), the frame
+            // face hosting uses; a dominant-axis projection turned X-facing sides 90°,
+            // mirrored some faces and stretched slopes.
+            const frame = getBlockFaceFrame(node.topology, face.id);
+            if (!(triangulated && frame))
+                continue;
+            const { xAxis, yAxis } = frame;
+            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));
+                    uvs.push(point[0] * xAxis[0] + point[1] * xAxis[1] + point[2] * xAxis[2], point[0] * yAxis[0] + point[1] * yAxis[1] + point[2] * yAxis[2]);
+                }
             }
+            faceRanges.push({ faceId: face.id, start, count: positions.length / 3 - start });
         }
-        const count = positions.length / 3 - start;
-        geometry.addGroup(start, count, materialIndexBySlotId.get(face.materialSlot) ?? 0);
-        faceRanges.push({ faceId: face.id, start, count });
+        const slotCount = positions.length / 3 - slotStart;
+        if (slotCount > 0)
+            geometry.addGroup(slotStart, slotCount, materialIndex);
     }
     geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
     geometry.setAttribute('normal', new Float32BufferAttribute(normals, 3));
@@ -134,7 +148,8 @@ export function buildBlockGeometry(node, ctx, shading = 'rendered', textures = t
         bodyFallbackSlotIds.push(slotId);
         return bodyMaterial;
     });
-    const mesh = new Mesh(geometry, materials);
+    // A single-slot block draws with one material, so node batching can pack it.
+    const mesh = new Mesh(geometry, materials.length === 1 ? materials[0] : materials);
     mesh.name = 'block-body';
     mesh.castShadow = true;
     mesh.receiveShadow = true;

package/dist/block/hosted-edit.d.ts

@@ -0,0 +1,13 @@
+import { type AnyNodeId, type BlockTopology, type SceneApi } from '@pascal-app/core';
+import { type HostedUpdate } from '../shared/hosted-resize';
+export declare const BLOCK_SUPPORT_REFUSAL = "This edit would remove support for an item on the block";
+type EditScene = Pick<SceneApi, 'get' | 'update' | 'applyChanges'>;
+export declare function planBlockTopologyEdit(scene: Pick<SceneApi, 'get'>, id: AnyNodeId, topology: BlockTopology): HostedUpdate[] | null;
+export declare function commitBlockTopologyEdit(scene: EditScene, id: AnyNodeId, topology: BlockTopology): boolean;
+export declare function createBlockTopologyPreview(id: AnyNodeId, scene: Pick<SceneApi, 'get' | 'markDirty'>): {
+    clear: () => void;
+    readonly valid: boolean;
+    set(topology: BlockTopology): boolean;
+};
+export {};
+//# sourceMappingURL=hosted-edit.d.ts.map

package/dist/block/hosted-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-edit.d.ts","sourceRoot":"","sources":["../../src/block/hosted-edit.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,aAAa,EAGlB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,yBAAyB,CAAA;AAI/E,eAAO,MAAM,qBAAqB,4DAA4D,CAAA;AAC9F,KAAK,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,cAAc,CAAC,CAAA;AAoBlE,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,EAC5B,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,aAAa,GACtB,YAAY,EAAE,GAAG,IAAI,CA+KvB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,aAAa,GACtB,OAAO,CAST;AAED,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,GAAG,WAAW,CAAC;;;kBAiB1B,aAAa;EAiB9B"}

package/dist/block/hosted-edit.js

@@ -0,0 +1,230 @@
+import { getBlockFaceFrame, surfaceRegionContainsPoint, useLiveNodeOverrides, } from '@pascal-app/core';
+import { attachmentBounds } from '@pascal-app/core/procedural-items';
+import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
+import { hostedChildUpdates } from '../shared/hosted-resize';
+import { blockFaceHost } from './face-host';
+import { blockSurfaceProvider, blockTopSurfaces } from './surface';
+export const BLOCK_SUPPORT_REFUSAL = 'This edit would remove support for an item on the block';
+function faceMatrix(host, faceId) {
+    const face = getBlockFaceFrame(host.topology, faceId);
+    if (!face)
+        return null;
+    return new Matrix4()
+        .makeBasis(new Vector3(...face.xAxis), new Vector3(...face.yAxis), new Vector3(...face.normal))
+        .setPosition(...face.origin);
+}
+function convertPose(child, matrix) {
+    const position = new Vector3(...child.position).applyMatrix4(matrix).toArray();
+    const rotation = new Euler().setFromQuaternion(new Quaternion()
+        .setFromRotationMatrix(matrix)
+        .multiply(new Quaternion().setFromEuler(new Euler(...child.rotation))));
+    return { position, rotation: [rotation.x, rotation.y, rotation.z] };
+}
+export function planBlockTopologyEdit(scene, id, topology) {
+    const host = scene.get(id);
+    if (host?.type !== 'block')
+        return null;
+    const children = host.children
+        .map((childId) => scene.get(childId))
+        .filter((child) => !!child && child.parentId === id);
+    if (!children.length)
+        return [[id, { topology }]];
+    const nextHost = { ...host, topology };
+    const before = Object.fromEntries([host, ...children].map((node) => [node.id, node]));
+    const after = { ...before, [id]: nextHost };
+    const updates = [];
+    const reconciled = new Set();
+    const nextSurfaces = blockTopSurfaces(nextHost);
+    const previousFaces = new Map(host.topology.faces.map((face) => [face.id, face]));
+    const nextFaces = new Map(topology.faces.map((face) => [face.id, face]));
+    const vertices = new Map(topology.vertices.map((v) => [v.id, v.position]));
+    const previousVertices = new Map(host.topology.vertices.map((v) => [v.id, v.position]));
+    const horizontal = new Map();
+    const translations = new Map();
+    const isHorizontal = (faceId) => {
+        if (!horizontal.has(faceId)) {
+            const frame = getBlockFaceFrame(topology, faceId);
+            horizontal.set(faceId, Math.abs(frame.normal[1] - 1) <= 1e-6 &&
+                nextFaces
+                    .get(faceId)
+                    .vertexIds.every((id) => Math.abs(vertices.get(id)[1] - frame.origin[1]) <= 1e-5));
+        }
+        return horizontal.get(faceId);
+    };
+    const translation = (faceId) => {
+        if (!translations.has(faceId)) {
+            const previous = previousFaces.get(faceId);
+            const next = nextFaces.get(faceId);
+            const delta = getBlockFaceFrame(topology, faceId).origin.map((v, i) => v - getBlockFaceFrame(host.topology, faceId).origin[i]);
+            const translated = previous.vertexIds.length === next.vertexIds.length &&
+                previous.vertexIds.every((id, i) => previousVertices
+                    .get(id)
+                    .every((v, axis) => Math.abs(v + delta[axis] - vertices.get(next.vertexIds[i])[axis]) <= 1e-5));
+            translations.set(faceId, translated ? delta : null);
+        }
+        return translations.get(faceId);
+    };
+    const replacementAt = (faceId, point) => {
+        const previous = previousFaces.get(faceId);
+        const next = nextFaces.get(faceId);
+        // A split both retains and adds boundary vertices; translations and insets must not rehome.
+        if (next &&
+            (!next.vertexIds.some((id) => previous?.vertexIds.includes(id)) ||
+                !next.vertexIds.some((id) => !previous?.vertexIds.includes(id))))
+            return undefined;
+        return nextSurfaces.find((surface) => {
+            if (surface.id === faceId)
+                return false;
+            const f = getBlockFaceFrame(topology, surface.id);
+            const distance = point.reduce((sum, v, i) => sum + (v - f.origin[i]) * f.normal[i], 0);
+            return (Math.abs(distance) < 1e-5 &&
+                surfaceRegionContainsPoint(surface.region, [point[0], point[2]]));
+        });
+    };
+    for (const child of children) {
+        if (child.type === 'item' && child.blockFaceId && child.asset.attachTo) {
+            const faceId = child.blockFaceId;
+            // A face stretched, trimmed or re-shaped in its own plane moves its centroid, the
+            // origin of the item's face frame: keep the item's pose instead of dragging it along.
+            // A face moved as a whole still carries it.
+            const previous = getBlockFaceFrame(host.topology, faceId);
+            const next = getBlockFaceFrame(topology, faceId);
+            if (!(previous && next && previousFaces.has(faceId) && nextFaces.has(faceId)))
+                continue;
+            if (translation(faceId))
+                continue;
+            if (previous.normal.some((value, axis) => Math.abs(value - next.normal[axis]) > 1e-6))
+                continue;
+            const shift = previous.origin.map((value, axis) => value - next.origin[axis]);
+            const along = (direction) => shift.reduce((sum, value, axis) => sum + value * direction[axis], 0);
+            // In-plane only: the item stays on the face if the face also moved along its normal.
+            const position = [
+                child.position[0] + along(next.xAxis),
+                child.position[1] + along(next.yAxis),
+                child.position[2],
+            ];
+            if (position.some((value, axis) => Math.abs(value - child.position[axis]) > 1e-9))
+                updates.push([child.id, { position }]);
+            continue;
+        }
+        if (child.type === 'item' && child.blockFaceId && !child.asset.attachTo) {
+            reconciled.add(child.id);
+            const matrix = faceMatrix(host, child.blockFaceId);
+            if (!matrix)
+                continue;
+            const oldPose = convertPose(child, matrix);
+            const oldRegion = nextSurfaces.find((surface) => surface.id === child.blockFaceId);
+            const replacement = !oldRegion ||
+                !surfaceRegionContainsPoint(oldRegion.region, [oldPose.position[0], oldPose.position[2]])
+                ? replacementAt(child.blockFaceId, oldPose.position)
+                : undefined;
+            if (replacement) {
+                const pose = convertPose({ ...child, ...oldPose }, faceMatrix(nextHost, replacement.id).invert());
+                const candidate = { ...child, ...pose, blockFaceId: replacement.id };
+                if (!blockFaceHost.isStoredPlacementValid({
+                    host: nextHost,
+                    item: candidate,
+                    asset: child.asset,
+                }))
+                    return null;
+                updates.push([child.id, { ...pose, blockFaceId: replacement.id }]);
+            }
+            else if (!blockFaceHost.isStoredPlacementValid({ host: nextHost, item: child, asset: child.asset }))
+                return null;
+            continue;
+        }
+        if (child.type !== 'procedural-item' || child.recipe.mounting)
+            continue;
+        const projected = attachmentBounds(child);
+        const point = [
+            (projected.min[0] + projected.max[0]) / 2,
+            projected.min[1],
+            (projected.min[2] + projected.max[2]) / 2,
+        ];
+        const previous = blockSurfaceProvider.resolveHit(host, { point, normalWorldY: 1 }, { scene: { nodes: () => before, get: scene.get } });
+        if (!previous || Math.abs(previous.position[1] - point[1]) > 1e-5 || previous.id === null)
+            continue;
+        const next = nextSurfaces.find((surface) => surface.id === previous.id);
+        if (next && isHorizontal(next.id)) {
+            const delta = translation(next.id);
+            if (delta && (Math.abs(delta[0]) > 1e-8 || Math.abs(delta[2]) > 1e-8)) {
+                if (!surfaceRegionContainsPoint(next.region, [point[0] + delta[0], point[2] + delta[2]]))
+                    return null;
+                updates.push([
+                    child.id,
+                    { position: child.position.map((v, i) => v + delta[i]) },
+                ]);
+                reconciled.add(child.id);
+                continue;
+            }
+        }
+        if (!next || !surfaceRegionContainsPoint(next.region, [point[0], point[2]])) {
+            const replacement = replacementAt(previous.id, point);
+            if (!replacement || !isHorizontal(replacement.id))
+                return null;
+            reconciled.add(child.id);
+            continue;
+        }
+        const previousFrame = getBlockFaceFrame(host.topology, previous.id);
+        // Host-local upright designs can follow a horizontal plane, not a tilted or warped support.
+        if (Math.abs(previousFrame.normal[1] - 1) > 1e-6 || !isHorizontal(next.id))
+            return null;
+    }
+    const changes = hostedChildUpdates(before, after, {
+        host: (node) => node.id === id,
+        child: (node) => !reconciled.has(node.id) && (node.type !== 'item' || !node.asset.attachTo),
+    });
+    return changes ? [[id, { topology }], ...updates, ...changes] : null;
+}
+export function commitBlockTopologyEdit(scene, id, topology) {
+    const updates = planBlockTopologyEdit(scene, id, topology);
+    if (!updates)
+        return false;
+    if (updates.length === 1)
+        scene.update(id, { topology });
+    else {
+        if (!scene.applyChanges)
+            return false;
+        scene.applyChanges({ update: updates.map(([id, data]) => ({ id, data })) });
+    }
+    return true;
+}
+export function createBlockTopologyPreview(id, scene) {
+    let owned = [];
+    let valid = true;
+    const clear = () => {
+        for (const [nodeId, patch] of owned) {
+            useLiveNodeOverrides.getState().clearFields(nodeId, Object.keys(patch));
+            if (nodeId !== id)
+                scene.markDirty(nodeId);
+        }
+        owned = [];
+        valid = true;
+    };
+    return {
+        clear,
+        get valid() {
+            return valid;
+        },
+        set(topology) {
+            const updates = planBlockTopologyEdit(scene, id, topology);
+            valid = updates !== null;
+            if (!updates)
+                return false;
+            const nextIds = new Set(updates.map(([nodeId]) => nodeId));
+            for (const [nodeId, patch] of owned) {
+                if (!nextIds.has(nodeId)) {
+                    useLiveNodeOverrides.getState().clearFields(nodeId, Object.keys(patch));
+                    if (nodeId !== id)
+                        scene.markDirty(nodeId);
+                }
+            }
+            owned = updates;
+            useLiveNodeOverrides.getState().setMany(updates);
+            for (const [nodeId] of updates)
+                if (nodeId !== id)
+                    scene.markDirty(nodeId);
+            return true;
+        },
+    };
+}

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

@@ -7,7 +7,7 @@ type SuccessfulBlockCommandResult = Extract<BlockCommandResult, {
 export type BlockOperationServices = {
     historyApi: SelectionAffordanceHistoryApi;
     readOnly: boolean;
-    sceneApi: Pick<SceneApi, 'get' | 'update'>;
+    sceneApi: Pick<SceneApi, 'get' | 'update' | 'applyChanges'>;
 };
 export type BlockLastOperation = {
     baseTopology: BlockTopology;