@pascal-app/nodes 1.0.3 → 1.0.5

package/README.md

@@ -32,3 +32,46 @@ for bootstrap ordering in a React application.
 ## License
 
 MIT
+
+## Kitchen agent tools
+
+The built-in plugin exports `builtinAgentTools` from `@pascal-app/nodes/agent-tools`
+(zod-only contracts) and `builtinAgentOperations` from
+`@pascal-app/nodes/agent-operations` (headless planners). Both the inspector and
+agents execute the same finishing planner, including hosted-item support checks.
+- `kitchen_finish_run({ runId, action: 'align' | 'fill' })` aligns a run or closes
+  50–150 mm wall gaps. Results apply in one undo step. Missing runs and unsupported
+  hosted items return `cabinet_run_not_found` and `hosted_items_unsupported`.
+- `kitchen_check_clearance({ nodeId })` returns an advisory opening warning for a
+  run or module. It shares the registry notice used during placement, movement,
+  and inspection. It checks conservative envelopes against visible floor objects
+  and straight walls; curved walls and wall openings are not resolved.
+
+A host that installs the plugin registers its tools on its MCP server with
+`registerOperationTool`, the shared tools' runner, under its own reviewed
+annotations (see the MCP README's plugin tools). Load the plugin definitions into
+the scene registry as usual: clearance queries read each installed kind's
+floor-placement capability.
+
+```ts
+import { registerOperationTool } from '@pascal-app/mcp/tools/shared-tools'
+import { builtinAgentOperations } from '@pascal-app/nodes/agent-operations'
+import { builtinAgentTools } from '@pascal-app/nodes/agent-tools'
+
+for (const contract of builtinAgentTools.tools) {
+  registerOperationTool(server, operations, {
+    contract,
+    operation: builtinAgentOperations[contract.name],
+    annotations: {
+      readOnlyHint: contract.name === 'kitchen_check_clearance',
+      destructiveHint: false,
+      openWorldHint: false,
+    },
+  })
+}
+```
+
+Hosted chat declares the same contracts and applies the same operation outcomes
+through its shared executor. These tools run as `operation` tools, so they do not
+need a browser executor or custom chat card. Hosts retain control of which tools
+are offered. The generic MCP server does not install a node plugin implicitly.

package/dist/agent-operations/index.d.ts

@@ -0,0 +1,12 @@
+import { checkKitchenClearance, finishKitchenRun } from '../cabinet/finish-operation.js';
+export { checkKitchenClearance, finishKitchenRun };
+export declare const builtinAgentOperations: {
+    kitchen_finish_run: import("@pascal-app/core/agent-operations").AgentOperation<{
+        runId: string;
+        action: 'align' | 'fill';
+    }>;
+    kitchen_check_clearance: import("@pascal-app/core/agent-operations").AgentOperation<{
+        nodeId: string;
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-operations/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAErF,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA;AAClD,eAAO,MAAM,sBAAsB;;;;;;;;CAGR,CAAA"}

package/dist/agent-operations/index.js

@@ -0,0 +1,6 @@
+import { checkKitchenClearance, finishKitchenRun } from '../cabinet/finish-operation.js';
+export { checkKitchenClearance, finishKitchenRun };
+export const builtinAgentOperations = {
+    kitchen_finish_run: finishKitchenRun,
+    kitchen_check_clearance: checkKitchenClearance,
+};

package/dist/agent-tools/index.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export declare const finishKitchenRunTool: {
+    name: 'kitchen_finish_run';
+    title: string;
+    description: string;
+    input: {
+        runId: z.ZodString;
+        action: z.ZodEnum<{
+            align: "align";
+            fill: "fill";
+        }>;
+    };
+    runsIn: 'operation';
+};
+export declare const checkKitchenClearanceTool: {
+    name: 'kitchen_check_clearance';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+    };
+    runsIn: 'operation';
+};
+export declare const builtinAgentTools: {
+    pluginId: string;
+    apiVersion: 1;
+    version: string;
+    tools: ({
+        name: 'kitchen_finish_run';
+        title: string;
+        description: string;
+        input: {
+            runId: z.ZodString;
+            action: z.ZodEnum<{
+                align: "align";
+                fill: "fill";
+            }>;
+        };
+        runsIn: 'operation';
+    } | {
+        name: 'kitchen_check_clearance';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+        };
+        runsIn: 'operation';
+    })[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/agent-tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,oBAAoB;IAC/B,IAAI,EAAE,oBAAoB;IAC1B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,KAAK;QAAc,MAAM;;;;;IAClC,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,yBAAyB;IACpC,IAAI,EAAE,yBAAyB;IAC/B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,MAAM;;IACf,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;cAftB,oBAAoB;;;;YAIjB,KAAK;YAAc,MAAM;;;;;gBAC1B,WAAW;;cAGb,yBAAyB;;;;YAItB,MAAM;;gBACP,WAAW;;CAOO,CAAA"}

package/dist/agent-tools/index.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const finishKitchenRunTool = {
+    name: 'kitchen_finish_run',
+    title: 'Finish kitchen run',
+    description: 'Align a cabinet run or fit wall fillers. align matches base heights, backs, reveals and handles while preserving tall appliances, compartments and hosted-item support. fill closes 50–150 mm gaps at exposed ends beside perpendicular walls without moving existing modules. Repeating fill is a no-op. Refuses cabinet_run_not_found or hosted_items_unsupported. One undo step.',
+    input: { runId: z.string(), action: z.enum(['align', 'fill']) },
+    runsIn: 'operation',
+};
+export const checkKitchenClearanceTool = {
+    name: 'kitchen_check_clearance',
+    title: 'Check kitchen opening clearance',
+    description: 'Check a cabinet run or module for advisory door and drawer opening clearance against visible floor-placed objects and straight walls on its level. Accounts for hosting transforms and floor support. Conservative envelopes, not exact hinge sweeps; curved walls and wall openings are not resolved. Does not change the scene. Requires the scene’s node definitions in the registry; refuses cabinet_not_found or node_capability_unavailable.',
+    input: { nodeId: z.string() },
+    runsIn: 'operation',
+};
+export const builtinAgentTools = {
+    pluginId: 'pascal:core',
+    apiVersion: 1,
+    version: '1.0.0',
+    tools: [finishKitchenRunTool, checkKitchenClearanceTool],
+};

package/dist/block/commands.d.ts

@@ -1,6 +1,6 @@
 import { type BlockFace, type BlockTopology } from '@pascal-app/core';
-import type { BlockSelection } from './selection-model';
-export type { BlockSelection } from './selection-model';
+import type { BlockSelection } from './selection-model.js';
+export type { BlockSelection } from './selection-model.js';
 type Point = [number, number, number];
 export type BlockCommand = {
     type: 'extrude-faces';

package/dist/block/contextual-help.js

@@ -1,4 +1,4 @@
-import useBlockEditSession from './edit-session';
+import useBlockEditSession from './edit-session.js';
 const MODE_LABELS = {
     vertex: 'Vertex',
     edge: 'Edge',

package/dist/block/definition.d.ts

@@ -1,5 +1,5 @@
 import { type BlockNode as BlockNodeType, type NodeDefinition } from '@pascal-app/core';
-import { BlockNode } from './schema';
+import { BlockNode } from './schema.js';
 export declare function blockBounds(node: BlockNodeType): {
     size: [number, number, number];
     center: [number, number, number];

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;AAIpC,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,CA6F5D,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,13 +1,27 @@
-import { createBoxBlockTopology, } from '@pascal-app/core';
-import { blockContextualHelp } from './contextual-help';
-import { blockFaceHost } from './face-host';
-import { buildBlockFloorplan } from './floorplan';
-import { buildBlockGeometry } from './geometry';
-import { blockPaint } from './paint';
-import { blockParametrics } from './parametrics';
-import { BlockNode } from './schema';
-import { blockSlots } from './slots';
-import { blockSurfaceProvider } from './surface';
+import { blockSlots, createBoxBlockTopology, } from '@pascal-app/core';
+import { perNodeGeometryBatchable } from '../shared/node-batch/batchable.js';
+import { blockContextualHelp } from './contextual-help.js';
+import { blockFaceHost } from './face-host.js';
+import { buildBlockFloorplan } from './floorplan.js';
+import { buildBlockGeometry } from './geometry.js';
+import { blockPaint } from './paint.js';
+import { blockParametrics } from './parametrics.js';
+import { BlockNode } from './schema.js';
+import { blockSurfaceProvider } from './surface.js';
+/** 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]);
@@ -47,7 +61,7 @@ export const blockDefinition = {
     snapProfile: 'structural',
     extensions: {
         'pascal:editor/floorplan': {
-            tool: () => import('./tool'),
+            tool: () => import('./tool.js'),
             preferredView: '3d',
         },
         'pascal:editor/contextual-help': blockContextualHelp,
@@ -65,6 +79,7 @@ export const blockDefinition = {
         slotNames: { body: 'Body' },
     }),
     capabilities: {
+        batchable: perNodeGeometryBatchable,
         selectable: { hitVolume: 'bbox' },
         surfaces: {
             hosting: blockSurfaceProvider,
@@ -91,7 +106,7 @@ export const blockDefinition = {
                     rotation: [0, node.rotation, 0],
                 };
             },
-            collides: true,
+            collides: (rawNode) => blockRestsOnFloor(rawNode),
         },
         paint: blockPaint,
         slots: (rawNode) => blockSlots(rawNode),
@@ -107,10 +122,10 @@ export const blockDefinition = {
     floorplan: buildBlockFloorplan,
     parametrics: blockParametrics,
     affordanceTools: {
-        selection: () => import('./selection'),
+        selection: () => import('./selection.js'),
     },
-    preview: () => import('./preview'),
-    tool: () => import('./tool'),
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Left click', label: 'Place block' },
         { key: 'Esc', label: 'Cancel' },

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

@@ -1,6 +1,6 @@
 import type { BlockTopology } from '@pascal-app/core';
-import type { BlockLastOperation } from './last-operation';
-import { type BlockSelectionState } from './selection-model';
+import type { BlockLastOperation } from './last-operation.js';
+import { type BlockSelectionState } from './selection-model.js';
 type BlockEditSessionState = {
     nodeId: string | null;
     selection: BlockSelectionState;

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

@@ -1 +1 @@
-{"version":3,"file":"edit-session.d.ts","sourceRoot":"","sources":["../../src/block/edit-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,mBAAmB,CAAA;AAElF,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,SAAS,EAAE,mBAAmB,CAAA;IAC9B,aAAa,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IAC/D,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACtE,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAA;IACrE,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,KAAK,IAAI,CAAA;CACjF,CAAA;AAID,QAAA,MAAM,mBAAmB,oFAmCtB,CAAA;AAEH,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"edit-session.d.ts","sourceRoot":"","sources":["../../src/block/edit-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,mBAAmB,CAAA;AAElF,KAAK,qBAAqB,GAAG;IAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,SAAS,EAAE,mBAAmB,CAAA;IAC9B,aAAa,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IAC/D,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,KAAK,IAAI,CAAA;IACtE,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAA;IACrE,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,KAAK,IAAI,CAAA;CACjF,CAAA;AAID,QAAA,MAAM,mBAAmB,oFAmCtB,CAAA;eAEY,mBAAmB"}

package/dist/block/edit-session.js

@@ -1,5 +1,5 @@
 import { create } from 'zustand';
-import { createBlockSelection } from './selection-model';
+import { createBlockSelection } from './selection-model.js';
 const emptySelection = () => createBlockSelection('face');
 const useBlockEditSession = create((set) => ({
     nodeId: null,

package/dist/block/face-host.js

@@ -1,6 +1,6 @@
 import { getBlockFaceFrame, surfaceRegionContainsPoint, } from '@pascal-app/core';
 import { Euler, Matrix4, Quaternion, Vector3 } from 'three';
-import { blockTopSurfaces } from './surface';
+import { blockTopSurfaces } from './surface.js';
 const BLOCK_HORIZONTAL_NORMAL_MIN_Y = 0.95;
 const BLOCK_VERTICAL_NORMAL_MAX_Y = 0.05;
 const BLOCK_FLOOR_ROTATION_X = Math.PI / 2;

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-snap.d.ts

@@ -1,7 +1,7 @@
 import type { BlockTopology } from '@pascal-app/core';
 import { type Camera, Vector3 } from 'three';
-import { type BlockSelection } from './commands';
-import type { BlockTransformConstraint } from './modal-transform';
+import { type BlockSelection } from './commands.js';
+import type { BlockTransformConstraint } from './modal-transform.js';
 type Point = [number, number, number];
 export type BlockGeometrySnap = {
     delta: Point;

package/dist/block/geometry-snap.js

@@ -1,6 +1,6 @@
 import { MathUtils, OrthographicCamera, PerspectiveCamera, Triangle, Vector3, } from 'three';
-import { blockSelectionVertexIds } from './commands';
-import { triangulateBlockFace } from './geometry';
+import { blockSelectionVertexIds } from './commands.js';
+import { triangulateBlockFace } from './geometry.js';
 export function blockGeometrySnapThreshold(camera, worldPoint, viewportHeight, worldScale, radiusPixels = 18) {
     let worldUnitsPerPixel = 0;
     if (camera instanceof PerspectiveCamera) {

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/gesture-wheel.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"gesture-wheel.d.ts","sourceRoot":"","sources":["../../src/block/gesture-wheel.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;aAAK,OAAO;aAAQ,OAAO;CAAkB,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/hosted-edit.d.ts

@@ -1,5 +1,5 @@
 import { type AnyNodeId, type BlockTopology, type SceneApi } from '@pascal-app/core';
-import { type HostedUpdate } from '../shared/hosted-resize';
+import { type HostedUpdate } from '../shared/hosted-resize.js';
 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;

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

@@ -1 +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,CAuJvB;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"}
+{"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"}