@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/lib/interaction/scope.ts

@@ -0,0 +1,243 @@
+// The authoritative description of "what the user is currently doing".
+//
+// Before this, that question was answered by re-deriving from 7+ independent
+// `useEditor` flags (`mode`, `tool`, `movingNode`, `placementDragMode`,
+// `activeHandleDrag`, `curvingWall`, `curvingFence`, `editingHole`,
+// `movingWallEndpoint`, `movingFenceEndpoint`, …). Every overlay and pick site
+// re-derived its behaviour from a different subset, so the flags could drift
+// into illegal combinations (moving + curving at once; a stale `movingNode`
+// after a drag ended). Collapsing them into one discriminated union makes those
+// combinations unrepresentable: a scope is exactly one interaction at a time,
+// and `idle` carries no interaction payload at all.
+
+import type { AnyNode } from '@pascal-app/core'
+
+export type InteractionView = '2d' | '3d'
+export type ReshapeDriver = 'tool' | 'floorplan'
+
+// Endpoint/curve/hole/boundary edits are all "reshape the selected node" — one
+// node, one in-flight reshape. Grouping them as sub-states of `reshaping`
+// (rather than four sibling scopes) keeps the union small while still making
+// "curving and hole-editing at once" unrepresentable.
+export type ReshapeKind = 'curve' | 'hole' | 'endpoint' | 'boundary' | 'control-point' | 'tangent'
+
+export type InteractionScope =
+  | { kind: 'idle' }
+  // Placing a fresh node (catalog/preset/build tool). `pressDrag` is the
+  // gizmo press-drag flavour (commit on release) vs click-to-place.
+  | {
+      kind: 'placing'
+      // The node being placed, carried inline: a fresh-placement / duplicate
+      // draft is not in the scene yet, so it cannot be recovered by id. Set once
+      // at `begin` and never mutated, so it is a stable reference for the gesture.
+      node: AnyNode
+      nodeId: string
+      nodeType: string
+      view: InteractionView
+      pressDrag: boolean
+    }
+  // Moving an existing node.
+  | { kind: 'moving'; node: AnyNode; nodeId: string; nodeType: string; view: InteractionView }
+  // Dragging a resize/translate/rotate handle of a selected node.
+  | { kind: 'handle-drag'; nodeId: string; handle: string }
+  // Click-to-click drafting of a polyline/polygon kind (wall/fence/slab/…).
+  | { kind: 'drafting'; tool: string }
+  // Reshaping a selected node's geometry (see ReshapeKind). `holeIndex` is set
+  // only for `reshape: 'hole'`; `endpoint` only for `reshape: 'endpoint'`.
+  | {
+      kind: 'reshaping'
+      nodeId: string
+      reshape: ReshapeKind
+      // Floorplan affordances own their commit and must not mount a second 3D reshape tool.
+      driver: ReshapeDriver
+      holeIndex?: number
+      endpoint?: 'start' | 'end'
+      index?: number
+      side?: 'in' | 'out'
+    }
+  // Marquee selection drag.
+  | { kind: 'box-select' }
+  // Material paint application.
+  | { kind: 'painting' }
+  // Terrain sculpting. Held for the whole time the sculpt tool is armed, not
+  // just while the pointer is down — the same lifetime as `painting`, and for
+  // the same reason: an *active* scope is what makes every other object's
+  // handles, the floating action menu, and the zone labels step back
+  // (`resolveOverlayPolicy`). A brush that only claimed the scope between
+  // pointer-down and -up would flicker all of that back on between dabs.
+  | { kind: 'sculpting' }
+
+export type InteractionKind = InteractionScope['kind']
+
+export type ActiveInteractionScope = Exclude<InteractionScope, { kind: 'idle' }>
+
+export const IDLE_SCOPE: InteractionScope = { kind: 'idle' }
+
+export function isIdle(scope: InteractionScope): scope is { kind: 'idle' } {
+  return scope.kind === 'idle'
+}
+
+export function isActive(scope: InteractionScope): scope is ActiveInteractionScope {
+  return scope.kind !== 'idle'
+}
+
+// The node a scope is acting on, if any. Drafting/box-select/painting/idle
+// target no single existing node.
+export function scopeNodeId(scope: InteractionScope): string | null {
+  switch (scope.kind) {
+    case 'placing':
+    case 'moving':
+    case 'handle-drag':
+    case 'reshaping':
+      return scope.nodeId
+    default:
+      return null
+  }
+}
+
+// The node a placing/moving scope is acting on, carried inline (see the
+// `placing` variant comment). Null for every other scope. Replaces the legacy
+// `useEditor.movingNode` flag: the node lives inside the discriminated union, so
+// it cannot survive past the interaction's `end()`.
+export function movingNodeOf(scope: InteractionScope): AnyNode | null {
+  return scope.kind === 'placing' || scope.kind === 'moving' ? scope.node : null
+}
+
+// Selection/hover picking is only meaningful while idle. During any active
+// interaction the pointer belongs to that interaction's body, not to selecting
+// a different object — the picking choke point should not route a hover/click
+// to selection while this is false.
+export function selectionEnabled(scope: InteractionScope): boolean {
+  return scope.kind === 'idle'
+}
+
+// Derived views of the scope that mirror the legacy `useEditor` flags they
+// replaced. Each returns null unless that exact interaction is active, so a
+// stale payload is unrepresentable: the value is a pure function of the single
+// authoritative scope, not an independent flag that can drift out of sync.
+
+// The legacy `activeHandleDrag` flag. `label` keeps the legacy field name so
+// downstream `=== ROTATE_HANDLE_DRAG_LABEL` / `=== 'height'` checks are unchanged.
+export function handleDragInfo(scope: InteractionScope): { nodeId: string; label: string } | null {
+  return scope.kind === 'handle-drag' ? { nodeId: scope.nodeId, label: scope.handle } : null
+}
+
+// The legacy `editingHole` flag (`SurfaceHoleTarget`).
+export function editingHoleInfo(
+  scope: InteractionScope,
+): { nodeId: string; holeIndex: number } | null {
+  return scope.kind === 'reshaping' && scope.reshape === 'hole' && scope.holeIndex !== undefined
+    ? { nodeId: scope.nodeId, holeIndex: scope.holeIndex }
+    : null
+}
+
+// Build the scope payload for a hole reshape, so producers don't re-spell the
+// discriminator at every call site.
+export function holeEditScope(target: {
+  nodeId: string
+  holeIndex: number
+  driver?: ReshapeDriver
+}): ActiveInteractionScope {
+  return {
+    kind: 'reshaping',
+    nodeId: target.nodeId,
+    reshape: 'hole',
+    holeIndex: target.holeIndex,
+    driver: target.driver ?? 'tool',
+  }
+}
+
+// True while the selected node's geometry is being curved (legacy
+// `curvingWall` / `curvingFence` — now one scope; the wall-vs-fence kind is
+// recovered from the reshaped node's type, looked up from the scene by nodeId).
+export function isCurveReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.reshape === 'curve'
+}
+
+export function isToolDrivenReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.driver === 'tool'
+}
+
+export function isFloorplanDrivenReshape(scope: InteractionScope): boolean {
+  return scope.kind === 'reshaping' && scope.driver === 'floorplan'
+}
+
+// The legacy `movingWallEndpoint` / `movingFenceEndpoint` flags minus the node
+// itself (consumers fetch the node from the scene by `nodeId`; it is stable for
+// the duration of the drag).
+export function endpointReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; endpoint: 'start' | 'end' } | null {
+  return scope.kind === 'reshaping' && scope.reshape === 'endpoint' && scope.endpoint !== undefined
+    ? { nodeId: scope.nodeId, endpoint: scope.endpoint }
+    : null
+}
+
+export function controlPointReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; index: number } | null {
+  return scope.kind === 'reshaping' &&
+    scope.reshape === 'control-point' &&
+    scope.index !== undefined
+    ? { nodeId: scope.nodeId, index: scope.index }
+    : null
+}
+
+export function tangentReshapeInfo(
+  scope: InteractionScope,
+): { nodeId: string; index: number; side: 'in' | 'out' } | null {
+  return scope.kind === 'reshaping' &&
+    scope.reshape === 'tangent' &&
+    scope.index !== undefined &&
+    scope.side !== undefined
+    ? { nodeId: scope.nodeId, index: scope.index, side: scope.side }
+    : null
+}
+
+// The id of the node being reshaped (any reshape kind), for the scene lookup
+// that recovers the full node payload a few consumers still need.
+export function reshapingNodeId(scope: InteractionScope): string | null {
+  return scope.kind === 'reshaping' ? scope.nodeId : null
+}
+
+// Builders so producers don't re-spell the discriminator at every call site.
+export function curveReshapeScope(
+  nodeId: string,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'curve', driver }
+}
+
+export function endpointReshapeScope(
+  nodeId: string,
+  endpoint: 'start' | 'end',
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'endpoint', endpoint, driver }
+}
+
+export function controlPointReshapeScope(
+  nodeId: string,
+  index: number,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'control-point', index, driver }
+}
+
+export function tangentReshapeScope(
+  nodeId: string,
+  index: number,
+  side: 'in' | 'out',
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'tangent', index, side, driver }
+}
+
+// Dragging a polygon vertex/edge (slab / ceiling boundary). Drives the snapping
+// HUD (no-angle 'polygon' set) and keeps the idle select hints off-screen.
+export function boundaryReshapeScope(
+  nodeId: string,
+  driver: ReshapeDriver = 'tool',
+): ActiveInteractionScope {
+  return { kind: 'reshaping', nodeId, reshape: 'boundary', driver }
+}

package/src/lib/level-duplication.test.ts

@@ -11,7 +11,7 @@ import { buildLevelDuplicateCreateOps } from './level-duplication'
 
 describe('buildLevelDuplicateCreateOps', () => {
   test('parents a duplicated bootstrap level back to its building', () => {
-    const level = LevelNode.parse({ level: 0, children: [] })
+    const level = LevelNode.parse({ level: 0, height: 3.25, children: [] })
     const building = BuildingNode.parse({ children: [level.id] })
     const wall = WallNode.parse({
       parentId: level.id,
@@ -36,6 +36,7 @@ describe('buildLevelDuplicateCreateOps', () => {
 
     expect(sourceLevel.parentId).toBeNull()
     expect(levelCreateOp?.parentId).toBe(building.id)
+    expect(levelCreateOp?.node.type === 'level' ? levelCreateOp.node.height : undefined).toBe(3.25)
   })
 
   test('does not copy spawn points from the source level', () => {

package/src/lib/level-selection.ts

@@ -5,10 +5,10 @@ import { useViewer } from '@pascal-app/viewer'
 function getAdjacentLevelIdForDeletion(levelId: AnyNodeId): LevelNode['id'] | null {
   const { nodes } = useScene.getState()
   const level = nodes[levelId]
-  if (!level || level.type !== 'level' || !level.parentId) return null
+  if (level?.type !== 'level' || !level.parentId) return null
 
   const building = nodes[level.parentId as AnyNodeId]
-  if (!building || building.type !== 'building') return null
+  if (building?.type !== 'building') return null
 
   const siblingLevelIds = (building as BuildingNode).children.filter(
     (childId): childId is LevelNode['id'] => nodes[childId as AnyNodeId]?.type === 'level',

package/src/lib/material-paint.ts

@@ -13,7 +13,6 @@ import {
   getEffectiveRoofSurfaceMaterial,
   getEffectiveSegmentSurfaceMaterial,
   getEffectiveStairSurfaceMaterial,
-  getEffectiveWallSurfaceMaterial,
   getLibraryMaterialIdFromRef,
   type MaterialSchema,
   type MaterialTarget,
@@ -26,28 +25,30 @@ import {
   type SlabNode,
   type StairNode,
   type StairSurfaceMaterialRole,
-  type WallNode,
   type WallSurfaceSide,
 } from '@pascal-app/core'
 
-export type PaintableMaterialTarget = Extract<
-  MaterialTarget,
-  | 'wall'
-  | 'roof'
-  | 'stair'
-  | 'fence'
-  | 'column'
-  | 'slab'
-  | 'ceiling'
-  | 'shelf'
-  | 'chimney'
-  | 'dormer'
-  | 'box-vent'
-  | 'ridge-vent'
-  | 'turbine-vent'
-  | 'cupola'
-  | 'eyebrow-vent'
->
+export type PaintableMaterialTarget =
+  | Extract<
+      MaterialTarget,
+      | 'wall'
+      | 'roof'
+      | 'stair'
+      | 'fence'
+      | 'column'
+      | 'slab'
+      | 'ceiling'
+      | 'shelf'
+      | 'cabinet'
+      | 'chimney'
+      | 'dormer'
+      | 'box-vent'
+      | 'ridge-vent'
+      | 'turbine-vent'
+      | 'cupola'
+      | 'eyebrow-vent'
+    >
+  | 'item'
 
 export type SingleSurfaceMaterialRole = 'surface'
 
@@ -76,32 +77,6 @@ export function getActivePaintMaterialLabel(material: ActivePaintMaterial | null
   return getCatalogEntryForActivePaintMaterial(material)?.label ?? 'Custom'
 }
 
-export function buildWallSurfaceMaterialPatch(
-  node: WallNode,
-  targetSide: WallSurfaceSide,
-  material: MaterialSchema | undefined,
-  materialPreset: string | undefined,
-): Partial<WallNode> {
-  const nextSurfaceMaterial = { material, materialPreset }
-  const nextInterior =
-    targetSide === 'interior'
-      ? nextSurfaceMaterial
-      : getEffectiveWallSurfaceMaterial(node, 'interior')
-  const nextExterior =
-    targetSide === 'exterior'
-      ? nextSurfaceMaterial
-      : getEffectiveWallSurfaceMaterial(node, 'exterior')
-
-  return {
-    interiorMaterial: nextInterior.material,
-    interiorMaterialPreset: nextInterior.materialPreset,
-    exteriorMaterial: nextExterior.material,
-    exteriorMaterialPreset: nextExterior.materialPreset,
-    material: undefined,
-    materialPreset: undefined,
-  }
-}
-
 export function buildRoofSurfaceMaterialPatch(
   node: RoofNode,
   targetRole: RoofSurfaceMaterialRole,
@@ -179,6 +154,7 @@ export function buildResetSurfaceMaterialUpdates(
       if (
         key === 'material' ||
         key === 'materialPreset' ||
+        key === 'slots' ||
         key.endsWith('Material') ||
         key.endsWith('MaterialPreset')
       ) {
@@ -276,6 +252,7 @@ export function resolveActivePaintMaterialFromSelection(params: {
       | ChimneyMaterialRole
       | DormerSurfaceMaterialRole
       | SingleSurfaceMaterialRole
+      | string
   } | null
 }): ActivePaintMaterial | null {
   const { nodes, selectedId, selectedMaterialTarget } = params
@@ -297,7 +274,7 @@ export function resolveActivePaintMaterialFromSelection(params: {
       nodes,
     })
     if (surface) {
-      const sourceTarget = selectedNode.type as PaintableMaterialTarget
+      const sourceTarget = (paintCap.materialTarget ?? selectedNode.type) as PaintableMaterialTarget
       return hasActivePaintMaterial({
         material: surface.material,
         materialPreset: surface.materialPreset,
@@ -375,11 +352,13 @@ export function resolveActivePaintMaterialFromSelection(params: {
   // Wall / chimney / dormer flow through the registry-driven path
   // at the top of this function.
 
+  // Slot-backed kinds resolve via the registry-driven `getEffectiveMaterial`
+  // path at the top of this function, including legacy inline-material
+  // fallbacks when their capability exposes one.
+
   if (
     (selectedNode.type === 'fence' ||
       selectedNode.type === 'column' ||
-      selectedNode.type === 'slab' ||
-      selectedNode.type === 'ceiling' ||
       selectedNode.type === 'shelf') &&
     selectedMaterialTarget.role === 'surface'
   ) {
@@ -412,6 +391,10 @@ export function resolvePaintTargetFromSelection(params: {
   const selectedNode = nodes[selectedId]
   if (!selectedNode) return null
 
+  const registryPaintTarget = nodeRegistry.get(selectedNode.type)?.capabilities?.paint
+    ?.materialTarget
+  if (registryPaintTarget) return registryPaintTarget as PaintableMaterialTarget
+
   if (selectedNode.type === 'wall') {
     return 'wall'
   }
@@ -444,6 +427,10 @@ export function resolvePaintTargetFromSelection(params: {
     return 'shelf'
   }
 
+  if (selectedNode.type === 'item') {
+    return 'item'
+  }
+
   if (selectedNode.type === 'chimney') {
     return 'chimney'
   }

package/src/lib/measurement-kind.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  CREATABLE_MEASUREMENT_KINDS,
+  DEFAULT_CREATABLE_MEASUREMENT_KIND,
+  normalizeCreatableMeasurementKind,
+} from './measurement-kind'
+
+describe('creatable measurement kinds', () => {
+  test('keeps the supported creation kinds', () => {
+    expect(CREATABLE_MEASUREMENT_KINDS).toEqual([
+      'distance',
+      'angle',
+      'area',
+      'perimeter',
+      'volume',
+    ])
+    for (const kind of CREATABLE_MEASUREMENT_KINDS) {
+      expect(normalizeCreatableMeasurementKind(kind)).toBe(kind)
+    }
+  })
+
+  test.each([
+    'smart',
+    'unknown',
+    null,
+    undefined,
+  ])('falls back from a non-creatable persisted value: %s', (value) => {
+    expect(normalizeCreatableMeasurementKind(value)).toBe(DEFAULT_CREATABLE_MEASUREMENT_KIND)
+  })
+})

package/src/lib/measurement-kind.ts

@@ -0,0 +1,19 @@
+export const CREATABLE_MEASUREMENT_KINDS = [
+  'distance',
+  'angle',
+  'area',
+  'perimeter',
+  'volume',
+] as const
+
+export type CreatableMeasurementKind = (typeof CREATABLE_MEASUREMENT_KINDS)[number]
+
+export const DEFAULT_CREATABLE_MEASUREMENT_KIND: CreatableMeasurementKind = 'distance'
+
+export function isCreatableMeasurementKind(value: unknown): value is CreatableMeasurementKind {
+  return CREATABLE_MEASUREMENT_KINDS.includes(value as CreatableMeasurementKind)
+}
+
+export function normalizeCreatableMeasurementKind(value: unknown): CreatableMeasurementKind {
+  return isCreatableMeasurementKind(value) ? value : DEFAULT_CREATABLE_MEASUREMENT_KIND
+}

package/src/lib/measurement-label.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+import { measurementCentroid, pointInPolygon2D } from '@pascal-app/core'
+import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from './measurement-label'
+
+describe('measurementPolygonLabelAnchor', () => {
+  test('keeps a concave polygon label inside its visible fill', () => {
+    const base = [
+      [0, 0, 0],
+      [4, 0, 0],
+      [4, 0, 1],
+      [1, 0, 1],
+      [1, 0, 4],
+      [0, 0, 4],
+    ] as [number, number, number][]
+    const centroid = measurementCentroid(base)
+    const anchor = measurementPolygonLabelAnchor(base)
+
+    expect(centroid).not.toBeNull()
+    expect(
+      pointInPolygon2D(
+        [centroid![0], centroid![2]],
+        base.map(([x, , z]) => [x, z]),
+      ),
+    ).toBe(false)
+    expect(anchor).not.toBeNull()
+    expect(
+      pointInPolygon2D(
+        [anchor![0], anchor![2]],
+        base.map(([x, , z]) => [x, z]),
+      ),
+    ).toBe(true)
+  })
+
+  test('returns an on-plane anchor for a sloped polygon', () => {
+    const base = [
+      [0, 0, 0],
+      [4, 2, 0],
+      [4, 2, 4],
+      [0, 0, 4],
+    ] as [number, number, number][]
+    const anchor = measurementPolygonLabelAnchor(base)
+
+    expect(triangulateMeasurementPolygon(base)).toHaveLength(2)
+    expect(anchor).not.toBeNull()
+    expect(anchor![1]).toBeCloseTo(anchor![0] / 2)
+  })
+})

package/src/lib/measurement-label.ts

@@ -0,0 +1,68 @@
+import { type MeasurementPoint, measurementCentroid, measurementNormal } from '@pascal-app/core'
+import { ShapeUtils, Vector2, Vector3 } from 'three'
+
+type MeasurementPolygonProjection = {
+  contour: Vector2[]
+  triangles: number[][]
+}
+
+function projectMeasurementPolygon(
+  points: readonly MeasurementPoint[],
+): MeasurementPolygonProjection | null {
+  const normalValue = measurementNormal(points)
+  const originValue = points[0]
+  if (!(normalValue && originValue)) return null
+
+  const normal = new Vector3(...normalValue)
+  const reference = Math.abs(normal.y) < 0.9 ? new Vector3(0, 1, 0) : new Vector3(1, 0, 0)
+  const tangent = new Vector3().crossVectors(reference, normal).normalize()
+  const bitangent = new Vector3().crossVectors(normal, tangent).normalize()
+  const origin = new Vector3(...originValue)
+  const contour = points.map((point) => {
+    const relative = new Vector3(...point).sub(origin)
+    return new Vector2(relative.dot(tangent), relative.dot(bitangent))
+  })
+
+  return { contour, triangles: ShapeUtils.triangulateShape(contour, []) }
+}
+
+export function triangulateMeasurementPolygon(points: readonly MeasurementPoint[]): number[][] {
+  return projectMeasurementPolygon(points)?.triangles ?? []
+}
+
+export function measurementPolygonLabelAnchor(
+  points: readonly MeasurementPoint[],
+): MeasurementPoint | null {
+  const projection = projectMeasurementPolygon(points)
+  if (!projection || projection.triangles.length === 0) return measurementCentroid(points)
+
+  let largestTriangle: number[] | null = null
+  let largestArea = Number.NEGATIVE_INFINITY
+  for (const triangle of projection.triangles) {
+    const [firstIndex, secondIndex, thirdIndex] = triangle
+    const first = firstIndex === undefined ? null : projection.contour[firstIndex]
+    const second = secondIndex === undefined ? null : projection.contour[secondIndex]
+    const third = thirdIndex === undefined ? null : projection.contour[thirdIndex]
+    if (!(first && second && third)) continue
+    const area = Math.abs(
+      (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x),
+    )
+    if (area > largestArea) {
+      largestArea = area
+      largestTriangle = triangle
+    }
+  }
+
+  if (!largestTriangle) return measurementCentroid(points)
+  const [firstIndex, secondIndex, thirdIndex] = largestTriangle
+  const first = firstIndex === undefined ? null : points[firstIndex]
+  const second = secondIndex === undefined ? null : points[secondIndex]
+  const third = thirdIndex === undefined ? null : points[thirdIndex]
+  if (!(first && second && third)) return measurementCentroid(points)
+
+  return [
+    (first[0] + second[0] + third[0]) / 3,
+    (first[1] + second[1] + third[1]) / 3,
+    (first[2] + second[2] + third[2]) / 3,
+  ]
+}