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

package/src/components/tools/shared/pointer-support-cap.test.ts

@@ -1,22 +1,53 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeAll, beforeEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
+  type AnyNodeDefinition,
   type AnyNodeId,
+  getWallBaseElevationForNodes,
+  ItemNode,
+  nodeRegistry,
+  registerNode,
+  type SlabNode,
   sceneRegistry,
   spatialGridManager,
   useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
-import { BoxGeometry, Mesh, MeshBasicMaterial, PerspectiveCamera } from 'three'
+import { hideFromScene, showInScene, useViewer } from '@pascal-app/viewer'
+import {
+  BoxGeometry,
+  Mesh,
+  MeshBasicMaterial,
+  OrthographicCamera,
+  PerspectiveCamera,
+  Vector3,
+} from 'three'
+import { z } from 'zod'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { createWallOnCurrentLevel } from '../wall/wall-drafting'
 import { resolvePointerSupportSurface } from './pointer-support-cap'
 
 const LEVEL_ID = 'level_test' as AnyNodeId
 const WALL_ID = 'wall_test' as AnyNodeId
+const PLATFORM_ID = 'plugin-platform_test' as AnyNodeId
+const PLATFORM_KIND = 'plugin-platform'
 
 describe('resolvePointerSupportSurface node tops', () => {
+  beforeAll(() => {
+    if (nodeRegistry.has(PLATFORM_KIND)) return
+    registerNode({
+      kind: PLATFORM_KIND,
+      schemaVersion: 1,
+      schema: z.object({}),
+      category: 'structure',
+      defaults: () => ({}),
+      capabilities: { surfaces: { top: { height: 2 } } },
+    } as unknown as AnyNodeDefinition)
+  })
+
   beforeEach(() => {
     spatialGridManager.clear()
     sceneRegistry.clear()
+    useInteractionScope.getState().end()
     useViewer.setState({
       selection: {
         buildingId: null,
@@ -59,12 +90,63 @@ describe('resolvePointerSupportSurface node tops', () => {
     sceneRegistry.clear()
   })
 
-  test('prefers the nearest upward-facing registered node surface over the ground', () => {
-    const wallMesh = new Mesh(new BoxGeometry(2, 2, 0.2), new MeshBasicMaterial())
-    wallMesh.position.y = 1
-    wallMesh.updateMatrixWorld(true)
-    sceneRegistry.nodes.set(WALL_ID, wallMesh)
-    sceneRegistry.byType.wall!.add(WALL_ID)
+  const addPluginPlatform = (z = 0, size: [number, number, number] = [4, 2, 4]) => {
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [PLATFORM_ID]: {
+          id: PLATFORM_ID,
+          type: PLATFORM_KIND,
+          object: 'node',
+          parentId: LEVEL_ID,
+          visible: true,
+          metadata: {},
+        } as unknown as AnyNode,
+      },
+    }))
+    const platformMesh = new Mesh(new BoxGeometry(...size), new MeshBasicMaterial())
+    platformMesh.position.set(0, 1, z)
+    platformMesh.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(PLATFORM_ID, platformMesh)
+    sceneRegistry.byType[PLATFORM_KIND]!.add(PLATFORM_ID)
+  }
+
+  test('keeps an off-center orthographic ray on the cursor line', () => {
+    const camera = new OrthographicCamera(-20, 20, 20, -20, -1000, 1000)
+    camera.position.set(10, 10, 10)
+    camera.lookAt(0, 0, 0)
+    camera.updateMatrixWorld(true)
+
+    const direction = camera.getWorldDirection(new Vector3())
+    const right = new Vector3(1, 0, 0).applyQuaternion(camera.quaternion)
+    const up = new Vector3(0, 1, 0).applyQuaternion(camera.quaternion)
+    const rayOrigin = camera.position.clone().addScaledVector(right, 3).addScaledVector(up, 2)
+    const groundDistance = -rayOrigin.y / direction.y
+    const worldHit = rayOrigin.clone().addScaledVector(direction, groundDistance)
+    const topDistance = (2 - rayOrigin.y) / direction.y
+    const expectedTop = rayOrigin.clone().addScaledVector(direction, topDistance)
+
+    addPluginPlatform(expectedTop.z, [0.5, 2, 0.5])
+    const platformMesh = sceneRegistry.nodes.get(PLATFORM_ID)!
+    platformMesh.position.set(expectedTop.x, 1, expectedTop.z)
+    platformMesh.updateMatrixWorld(true)
+
+    const support = resolvePointerSupportSurface(
+      camera,
+      worldHit.toArray() as [number, number, number],
+      {
+        includeNodeTopSurfaces: true,
+      },
+    )
+
+    expect(support?.sourceNodeId).toBe(PLATFORM_ID)
+    expect(support?.worldPoint?.[0]).toBeCloseTo(expectedTop.x)
+    expect(support?.worldPoint?.[1]).toBeCloseTo(expectedTop.y)
+    expect(support?.worldPoint?.[2]).toBeCloseTo(expectedTop.z)
+  })
+
+  test('discovers a plugin-declared top surface without a kind-name list', () => {
+    addPluginPlatform()
 
     const camera = new PerspectiveCamera()
     camera.position.set(0, 5, 0)
@@ -74,25 +156,245 @@ describe('resolvePointerSupportSurface node tops', () => {
       includeNodeTopSurfaces: true,
     })
 
-    expect(support?.sourceNodeId).toBe(WALL_ID)
+    expect(support?.sourceNodeId).toBe(PLATFORM_ID)
     expect(support?.elevation).toBeCloseTo(2)
     expect(support?.worldPoint).toEqual([0, 2, 0])
   })
 
-  test('keeps the ground result when node-top surfaces are not requested', () => {
-    const wallMesh = new Mesh(new BoxGeometry(2, 2, 0.2), new MeshBasicMaterial())
-    wallMesh.position.y = 1
-    wallMesh.updateMatrixWorld(true)
-    sceneRegistry.nodes.set(WALL_ID, wallMesh)
-    sceneRegistry.byType.wall!.add(WALL_ID)
+  test('keeps an unhovered item top above a batched slab across batch transitions', () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    const item = ItemNode.parse({
+      id: 'item_support_batch',
+      parentId: LEVEL_ID,
+      asset: {
+        id: 'table',
+        name: 'Table',
+        src: '/table.glb',
+        category: 'furniture',
+        thumbnail: '/table.png',
+        dimensions: [4, 2, 4],
+      },
+    })
+    const slab = {
+      id: 'slab_support_batch',
+      type: 'slab',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-3, -3],
+        [3, -3],
+        [3, 3],
+        [-3, 3],
+      ],
+      elevation: 0.25,
+      thickness: 0.25,
+      holes: [],
+      visible: true,
+    } as unknown as SlabNode
+    const itemMesh = new Mesh(new BoxGeometry(4, 2, 4), new MeshBasicMaterial())
+    itemMesh.position.y = 1.25
+    itemMesh.updateMatrixWorld(true)
+    const slabMesh = new Mesh(new BoxGeometry(6, 0.25, 6), new MeshBasicMaterial())
+    slabMesh.position.y = 0.125
+    slabMesh.updateMatrixWorld(true)
+    try {
+      registerNode({
+        kind: 'item',
+        schema: ItemNode,
+        schemaVersion: 1,
+        category: 'furnish',
+        defaults: () => ({}),
+        capabilities: { surfaces: { top: { height: 2 } } },
+      } as unknown as AnyNodeDefinition)
+      useScene.setState((state) => ({
+        nodes: { ...state.nodes, [item.id]: item, [slab.id]: slab },
+      }))
+      sceneRegistry.nodes.set(item.id, itemMesh)
+      sceneRegistry.byType.item!.add(item.id)
+      sceneRegistry.nodes.set(slab.id, slabMesh)
+      sceneRegistry.byType.slab!.add(slab.id)
+      spatialGridManager.handleNodeCreated(slab as AnyNode, LEVEL_ID)
+      useViewer.setState({ hoveredId: null })
+      const camera = new PerspectiveCamera()
+      camera.position.set(0, 5, 0)
+      camera.updateMatrixWorld(true)
+      for (const batched of [false, true, false]) {
+        for (const mesh of [itemMesh, slabMesh]) {
+          if (batched) hideFromScene(mesh, 'batched')
+          else showInScene(mesh, 'batched')
+        }
+        const top = resolvePointerSupportSurface(camera, [0, 0, 0], {
+          includeNodeTopSurfaces: true,
+        })
+        expect(top?.sourceNodeId).toBe(item.id)
+        expect(top?.worldPoint).toEqual([0, 2.25, 0])
+        const floor = resolvePointerSupportSurface(camera, [0, 0, 0])
+        expect(floor?.supportSlabId).toBe(slab.id)
+        expect(floor?.worldPoint).toEqual([0, 0.25, 0])
+      }
+    } finally {
+      restoreRegistry()
+      for (const mesh of [itemMesh, slabMesh]) {
+        mesh.geometry.dispose()
+        mesh.material.dispose()
+      }
+    }
+  })
+
+  test('keeps the ground result unless node-top surfaces are asked for', () => {
+    addPluginPlatform()
+
+    const camera = new PerspectiveCamera()
+    camera.position.set(0, 5, 0)
+    camera.updateMatrixWorld(true)
+
+    // The default. A floor placement aims THROUGH whatever upward-facing
+    // geometry sits between the camera and the floor — a room's ceiling, the
+    // top of the wall the ray passes over — so only the tools that build on a
+    // surface opt in.
+    for (const options of [undefined, { includeNodeTopSurfaces: false }]) {
+      const support = resolvePointerSupportSurface(camera, [0, 0, 0], options)
+      expect(support?.sourceNodeId).toBeNull()
+      expect(support?.elevation).toBe(0)
+    }
+  })
+
+  test('never elects the node the active interaction is placing or moving', () => {
+    addPluginPlatform()
+    useInteractionScope.getState().begin({
+      kind: 'placing',
+      node: useScene.getState().nodes[PLATFORM_ID]!,
+      nodeId: PLATFORM_ID,
+      nodeType: PLATFORM_KIND,
+      view: '3d',
+      pressDrag: false,
+      driver: 'registry-tool',
+    })
 
     const camera = new PerspectiveCamera()
     camera.position.set(0, 5, 0)
     camera.updateMatrixWorld(true)
 
-    const support = resolvePointerSupportSurface(camera, [0, 0, 0])
+    const support = resolvePointerSupportSurface(camera, [0, 0, 0], {
+      includeNodeTopSurfaces: true,
+    })
 
+    // Its own top would raise it by its own height on every pointer move.
     expect(support?.sourceNodeId).toBeNull()
     expect(support?.elevation).toBe(0)
   })
+
+  test('uses a plugin-declared top as the wall construction surface', () => {
+    const lowSlab = {
+      id: 'slab_low',
+      type: 'slab',
+      object: 'node',
+      parentId: LEVEL_ID,
+      visible: true,
+      metadata: {},
+      children: [],
+      polygon: [
+        [-2, 1],
+        [2, 1],
+        [2, 3],
+        [-2, 3],
+      ],
+      holes: [],
+      holeMetadata: [],
+      elevation: 0.25,
+      thickness: 0.25,
+      recessed: false,
+      autoFromWalls: false,
+    } as SlabNode
+    const highSlab = {
+      ...lowSlab,
+      id: 'slab_high',
+      polygon: [
+        [-1, 1],
+        [0, 1],
+        [0, 3],
+        [-1, 3],
+      ],
+      elevation: 1,
+    } as SlabNode
+    useScene.setState((state) => ({
+      nodes: {
+        ...state.nodes,
+        [lowSlab.id]: lowSlab,
+        [highSlab.id]: highSlab,
+      },
+    }))
+    spatialGridManager.handleNodeCreated(lowSlab as AnyNode, LEVEL_ID)
+    spatialGridManager.handleNodeCreated(highSlab as AnyNode, LEVEL_ID)
+    addPluginPlatform(2)
+
+    const camera = new PerspectiveCamera()
+    camera.position.set(0, 5, 2)
+    camera.updateMatrixWorld(true)
+
+    const support = resolvePointerSupportSurface(camera, [0, 0, 2], {
+      includeNodeTopSurfaces: true,
+    })
+
+    expect(support?.sourceNodeId).toBe(PLATFORM_ID)
+    expect(support?.elevation).toBeCloseTo(2)
+    expect(support?.worldPoint).toEqual([0, 2, 2])
+
+    const wall = createWallOnCurrentLevel([-0.75, 2], [0.75, 2], {
+      supportCap: support?.elevation,
+      preferredSupportSlabId: support?.supportSlabId,
+      constructionElevation: support?.elevation,
+      constructionHeight: 2.5,
+      flatConstructionBase: support?.sourceNodeId != null,
+    })
+    expect(wall).not.toBeNull()
+    expect(getWallBaseElevationForNodes(wall!, useScene.getState().nodes)).toBeCloseTo(2)
+    const wallSupport = spatialGridManager.getSlabSupportForWall(
+      LEVEL_ID,
+      wall!.start,
+      wall!.end,
+      wall!.curveOffset,
+      wall!.thickness,
+      wall!.supportSlabId,
+      undefined,
+      wall!.supportOffset,
+    )
+    expect(
+      wallSupport.baseSegments.every((segment) => Math.abs(segment.elevation - 2) < 1e-6),
+    ).toBe(true)
+  })
+
+  test('tolerates a registered definition without capabilities', () => {
+    // Gates the pollution class behind the night-8 CI flake (run
+    // 32580694134): `capabilities` is typed required, but a minimal plugin
+    // definition (or a leaked test fixture) can ship without it at runtime.
+    // The resolver enumerates every registered kind, so one capabilities-less
+    // entry must read as "no top surface" — not crash the election.
+    const restoreRegistry = nodeRegistry._snapshot()
+    try {
+      registerNode({
+        kind: 'plugin-minimal-capless',
+        schemaVersion: 1,
+        schema: z.object({}),
+        category: 'structure',
+        defaults: () => ({}),
+        // No `capabilities` — deliberately.
+      } as unknown as AnyNodeDefinition)
+      addPluginPlatform()
+
+      const camera = new PerspectiveCamera()
+      camera.position.set(0, 5, 0)
+      camera.updateMatrixWorld(true)
+
+      const support = resolvePointerSupportSurface(camera, [0, 0, 0], {
+        includeNodeTopSurfaces: true,
+      })
+
+      // No throw, and the election still works: the capabilities-less kind is
+      // skipped while the platform's declared top is found as usual.
+      expect(support?.sourceNodeId).toBe(PLATFORM_ID)
+      expect(support?.elevation).toBeCloseTo(2)
+    } finally {
+      restoreRegistry()
+    }
+  })
 })

package/src/components/tools/shared/pointer-support-cap.ts

@@ -4,13 +4,16 @@ import {
   GROUND_SUPPORT_ID,
   type ItemNode,
   isLowProfileItemSurface,
+  nodeRegistry,
   sceneRegistry,
   spatialGridManager,
   useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { setSurfaceRaycastLayers, useViewer } from '@pascal-app/viewer'
 import { type Camera, Matrix3, type Object3D, Raycaster, Vector3 } from 'three'
 import { resolveTerrainGroundHit } from '../../../lib/ground-surface'
+import { scopeNodeId } from '../../../lib/interaction/scope'
+import useInteractionScope from '../../../store/use-interaction-scope'
 
 const originScratch = new Vector3()
 const hitScratch = new Vector3()
@@ -19,11 +22,10 @@ const pointScratch = new Vector3()
 const worldRayOrigin = new Vector3()
 const worldRayDirection = new Vector3()
 const nodeTopRaycaster = new Raycaster()
+setSurfaceRaycastLayers(nodeTopRaycaster.layers)
 const nodeTopNormal = new Vector3()
 const nodeTopNormalMatrix = new Matrix3()
 
-const NODE_TOP_SURFACE_KINDS = ['wall', 'item', 'column'] as const
-
 export type PointerSupportSurface = {
   /** Level-local elevation of the pointed surface — the election cap. */
   elevation: number
@@ -85,7 +87,19 @@ export function resolvePointerSupportSurface(
   // The world ray, kept before the level conversion below: the terrain field is
   // world-space (site geometry, not level-local), so the march needs this frame.
   camera.getWorldPosition(worldRayOrigin)
-  worldRayDirection.set(worldHit[0], worldHit[1], worldHit[2]).sub(worldRayOrigin)
+  const cameraToHit = hitScratch.set(worldHit[0], worldHit[1], worldHit[2]).sub(worldRayOrigin)
+  if ((camera as Camera & { isOrthographicCamera?: boolean }).isOrthographicCamera) {
+    // For an orthographic camera every screen pixel has the same direction. The
+    // hit point is offset from the camera along the view plane, so using
+    // `camera.position -> hit` tilts the ray toward the screen centre and makes
+    // support surfaces drift away from the cursor off-axis.
+    camera.getWorldDirection(worldRayDirection).normalize()
+    worldRayOrigin
+      .set(worldHit[0], worldHit[1], worldHit[2])
+      .addScaledVector(worldRayDirection, -cameraToHit.dot(worldRayDirection))
+  } else {
+    worldRayDirection.copy(cameraToHit).normalize()
+  }
 
   originScratch.copy(worldRayOrigin)
   hitScratch.set(worldHit[0], worldHit[1], worldHit[2])
@@ -151,16 +165,39 @@ export function resolvePointerSupportSurface(
     localPoint = [pointScratch.x, pointScratch.y, pointScratch.z]
   }
 
-  if (options?.includeNodeTopSurfaces) {
+  // Node tops are opt-in. A ray aimed at a floor crosses every upward-facing
+  // face above that floor first — a room's ceiling, the top of the wall it
+  // passes over — so electing "the nearest node top along the ray" silently
+  // lifts anything placed inside a finished room. Only the tools that build ON
+  // a surface (wall / column / fence / stair / block) mean that, and they say
+  // so. Everything else places against the floor the pointer indicates.
+  //
+  // `capabilities` is typed required on NodeDefinition, but this enumerates
+  // EVERY registered kind — including plugin bundles that bypass the type at
+  // runtime. A minimal definition without `capabilities` must read as "no top
+  // surface", not crash the resolver (night-8 CI, run 32580694134).
+  const nodeTopSurfaceKinds = options?.includeNodeTopSurfaces
+    ? Array.from(nodeRegistry.entries())
+        .filter(([, definition]) => definition.capabilities?.surfaces?.top !== undefined)
+        .map(([kind]) => kind)
+    : []
+  if (nodeTopSurfaceKinds.some((kind) => (sceneRegistry.byType[kind]?.size ?? 0) > 0)) {
     nodeTopRaycaster.set(worldRayOrigin, worldRayDirection.clone().normalize())
     const nodes = useScene.getState().nodes
     const registeredOwners = new Map(
       [...sceneRegistry.nodes.entries()].map(([nodeId, object]) => [object, nodeId as AnyNodeId]),
     )
-    const belongsToActiveLevel = (nodeId: AnyNodeId) => {
+    // The node the active interaction is placing/moving cannot be a surface for
+    // itself: its mesh rides the cursor, so electing its own top would raise it
+    // by its own height on every pointer move. Tools neuter the dragged mesh's
+    // `raycast` for their own pointer routing, but that is each tool's private
+    // convention — the election owns the invariant.
+    const interactingNodeId = scopeNodeId(useInteractionScope.getState().scope)
+    const isEligibleCandidate = (nodeId: AnyNodeId) => {
       let current = nodes[nodeId]
       const visited = new Set<AnyNodeId>()
       while (current && !visited.has(current.id)) {
+        if (current.id === interactingNodeId) return false
         if (current.id === levelId) return true
         visited.add(current.id)
         current = current.parentId ? nodes[current.parentId as AnyNodeId] : undefined
@@ -179,12 +216,12 @@ export function resolvePointerSupportSurface(
         }
       | undefined
 
-    for (const kind of NODE_TOP_SURFACE_KINDS) {
+    for (const kind of nodeTopSurfaceKinds) {
       for (const rawId of sceneRegistry.byType[kind] ?? []) {
         const nodeId = rawId as AnyNodeId
         const node = nodes[nodeId]
         const object = sceneRegistry.nodes.get(nodeId)
-        if (!(node?.visible && object?.visible && belongsToActiveLevel(nodeId))) continue
+        if (!(node?.visible && object?.visible && isEligibleCandidate(nodeId))) continue
         if (
           node.type === 'item' &&
           (!canHostOnTop(node) || isLowProfileItemSurface(node as ItemNode))

package/src/components/tools/site/terrain-brush-cursor.tsx

@@ -79,6 +79,7 @@ export const TerrainBrushCursor: React.FC<{
   const sampling = useEditor((state) => state.terrainSampling)
   const color = brushRingColor(verb, sampling)
   const unit = useViewer((state) => state.unit)
+  const metricNotation = useViewer((state) => state.metricNotation)
 
   const lineRef = useRef<Line>(null)
   const centerRef = useRef<Group>(null)
@@ -195,7 +196,7 @@ export const TerrainBrushCursor: React.FC<{
 
     const centerHeight = surfaceHeightAt(surface, hit.x, hit.z)
     center.position.set(hit.x, centerHeight + RING_LIFT, hit.z)
-    const heightLabel = `H ${formatMeasurement(centerHeight, unit)}`
+    const heightLabel = `H ${formatMeasurement(centerHeight, unit, metricNotation)}`
     if (heightRef.current) {
       heightRef.current.style.display = ''
       if (heightLabel !== lastHeightLabelRef.current) {

package/src/components/tools/site/terrain-sculpt-grid.tsx

@@ -39,10 +39,15 @@ function writeGridHeights(
     }
   }
 
+  let first = (row0 * field.cols + col0) * 3
+  let end = ((row1 - 1) * field.cols + col1) * 3
+  // Several dabs can precede a render; none may discard an earlier pending upload.
+  for (const pending of attribute.updateRanges) {
+    first = Math.min(first, pending.start)
+    end = Math.max(end, pending.start + pending.count)
+  }
   attribute.clearUpdateRanges()
-  const first = (row0 * field.cols + col0) * 3
-  const last = ((row1 - 1) * field.cols + (col1 - 1)) * 3 + 2
-  attribute.addUpdateRange(first, last - first + 1)
+  attribute.addUpdateRange(first, end - first)
   attribute.needsUpdate = true
 }
 
@@ -162,7 +167,7 @@ export function TerrainSculptGrid({
       if (stroke?.lastPatch && stroke.lastPatch !== lastPatch) {
         lastPatch = stroke.lastPatch
         writeGridHeights(attribute, stroke.field, stroke.lastPatch)
-        target.geometry.computeBoundingSphere()
+        // This grid is neither frustum-culled nor raycast, so no per-dab bounds scan.
         return
       }
 
@@ -173,7 +178,6 @@ export function TerrainSculptGrid({
         const restored = terrainFieldOf(current) ?? sculptFieldForSite(current)
         if (restored.cols !== field.cols || restored.rows !== field.rows) return
         writeGridHeights(attribute, restored, null)
-        target.geometry.computeBoundingSphere()
       }
     })
   }, [field.cols, field.rows, site.id])

package/src/components/tools/site/terrain-sculpt-tool.tsx

@@ -214,7 +214,7 @@ export const TerrainSculptTool: React.FC = () => {
         detachStrokeAnchor(active.stroke)
         return
       }
-      const point = groundPoint(event, active.field)
+      const point = groundPoint(event, active.stroke.snapshot)
       if (!point) return
       const brushPatch = advanceStroke(active.stroke, point[0], point[1])
       if (!brushPatch) return