@pascal-app/editor 1.0.7 → 1.1.1

package/src/lib/floorplan/geometry.ts

@@ -1,68 +1,5 @@
-import type { Point2D } from '@pascal-app/core'
-import { getWallFaceOffsets, type WallJustification } from '@pascal-app/core'
-import type { FloorplanLineSegment, FloorplanSelectionBounds } from './types'
-
-// Baseline rotation (deg) that orients the plan-local scene "north up" on
-// screen. The on-screen floor-plan scene `<g>` is rotated by
-// `FLOORPLAN_VIEW_ROTATION_DEG + userRotation - buildingRotation`; PDF export
-// uses the same user rotation so its orientation matches the live plan.
-//
-// North is world −Z: with a 0 baseline a rotation-0 reference image (top =
-// −Z) reads upright in the north-aligned view, and "align north" maps to a
-// 3D camera azimuth of 0. The old 90° baseline made north world −X, so
-// north-up floorplan scans displayed sideways whenever the compass claimed
-// the view was aligned.
-export const FLOORPLAN_VIEW_ROTATION_DEG = 0
-
-export function clampPlanValue(value: number, min: number, max: number) {
-  return Math.min(Math.max(value, min), max)
-}
-
-export function rotatePlanVector(x: number, y: number, rotation: number): [number, number] {
-  const cos = Math.cos(rotation)
-  const sin = Math.sin(rotation)
-  return [x * cos + y * sin, -x * sin + y * cos]
-}
-
-// Converts a world X/Z point into the floor-plan-local (building-local)
-// frame used by the SVG scene `<g>` and every stored node position. The
-// inverse of `floorplanLocalToWorldPoint`. Shared so the floor-plan panel
-// and the 2D move overlay resolve the same frame — feeding a world-space
-// `original` into a local-space cursor solver lands the drop off by the
-// building's world X/Z (worse for an off-origin building).
-export function worldToFloorplanLocalPoint(
-  worldX: number,
-  worldZ: number,
-  buildingPosition: readonly [number, number, number],
-  buildingRotationY: number,
-): Point2D {
-  const dx = worldX - buildingPosition[0]
-  const dz = worldZ - buildingPosition[2]
-  const cos = Math.cos(buildingRotationY)
-  const sin = Math.sin(buildingRotationY)
-
-  return {
-    x: dx * cos - dz * sin,
-    y: dx * sin + dz * cos,
-  }
-}
-
-// Inverse of `worldToFloorplanLocalPoint`: floor-plan-local X/Y → world X/Z.
-export function floorplanLocalToWorldPoint(
-  point: Point2D | [number, number],
-  buildingPosition: readonly [number, number, number],
-  buildingRotationY: number,
-): { x: number; z: number } {
-  const localX = Array.isArray(point) ? point[0] : point.x
-  const localY = Array.isArray(point) ? point[1] : point.y
-  const cos = Math.cos(buildingRotationY)
-  const sin = Math.sin(buildingRotationY)
-
-  return {
-    x: buildingPosition[0] + localX * cos + localY * sin,
-    z: buildingPosition[2] - localX * sin + localY * cos,
-  }
-}
+import { clampPlanValue, type Point2D, rotatePlanVector } from '@pascal-app/core'
+import type { FloorplanSelectionBounds } from './types'
 
 export function getRotatedRectanglePolygon(
   center: Point2D,
@@ -88,53 +25,6 @@ export function getRotatedRectanglePolygon(
   })
 }
 
-export function interpolatePlanPoint(start: Point2D, end: Point2D, t: number): Point2D {
-  return {
-    x: start.x + (end.x - start.x) * t,
-    y: start.y + (end.y - start.y) * t,
-  }
-}
-
-export function getPlanPointDistance(start: Point2D, end: Point2D): number {
-  return Math.hypot(end.x - start.x, end.y - start.y)
-}
-
-export function movePlanPointTowards(start: Point2D, end: Point2D, distance: number): Point2D {
-  const totalDistance = getPlanPointDistance(start, end)
-  if (totalDistance <= Number.EPSILON || distance <= 0) {
-    return start
-  }
-
-  return interpolatePlanPoint(start, end, Math.min(1, distance / totalDistance))
-}
-
-export function getThickPlanLinePolygon(
-  line: FloorplanLineSegment,
-  thickness: number,
-  justification?: WallJustification,
-): Point2D[] {
-  const dx = line.end.x - line.start.x
-  const dy = line.end.y - line.start.y
-  const length = Math.hypot(dx, dy)
-
-  if (length <= Number.EPSILON || thickness <= 0) {
-    return [line.start, line.end, line.end, line.start]
-  }
-
-  const { a, b } = getWallFaceOffsets({ thickness, justification })
-  const normalX = (-dy / length) * a
-  const normalY = (dx / length) * a
-
-  const backX = (-dy / length) * -b
-  const backY = (dx / length) * -b
-  return [
-    { x: line.start.x + normalX, y: line.start.y + normalY },
-    { x: line.end.x + normalX, y: line.end.y + normalY },
-    { x: line.end.x - backX, y: line.end.y - backY },
-    { x: line.start.x - backX, y: line.start.y - backY },
-  ]
-}
-
 export function getFloorplanSelectionBounds(
   start: [number, number],
   end: [number, number],

package/src/lib/floorplan/index.ts

@@ -6,23 +6,14 @@ export {
   type FloorplanAlignmentResult,
 } from './apply-alignment'
 export {
-  clampPlanValue,
   doesPolygonIntersectSelectionBounds,
-  FLOORPLAN_VIEW_ROTATION_DEG,
-  floorplanLocalToWorldPoint,
   getDistanceToWallSegment,
   getFloorplanSelectionBounds,
-  getPlanPointDistance,
   getRotatedRectanglePolygon,
-  getThickPlanLinePolygon,
-  interpolatePlanPoint,
   isPointInsidePolygon,
   isPointInsidePolygonWithHoles,
   isPointInsideSelectionBounds,
-  movePlanPointTowards,
   pointMatchesWallPlanPoint,
-  rotatePlanVector,
-  worldToFloorplanLocalPoint,
 } from './geometry'
 export {
   buildFloorplanItemEntry,

package/src/lib/floorplan/items.ts

@@ -6,9 +6,10 @@ import {
   getWallLocalFaceZ,
   type ItemNode,
   type LevelNode,
+  rotatePlanVector,
   useLiveTransforms,
 } from '@pascal-app/core'
-import { getRotatedRectanglePolygon, rotatePlanVector } from './geometry'
+import { getRotatedRectanglePolygon } from './geometry'
 import type { FloorplanItemEntry, FloorplanNodeTransform, LevelDescendantMap } from './types'
 
 export function collectLevelDescendants(

package/src/lib/floorplan/open-wall-ends.ts

@@ -1,11 +1,12 @@
 import {
+  formatLinearMeasurement,
+  type LinearUnit,
   type OpenWallEnd,
   planJoinOpenWallEnd,
   runAsSingleSceneHistoryStep,
   useScene,
   type WallJoinResult,
 } from '@pascal-app/core'
-import { formatLinearMeasurement, type LinearUnit } from '../measurements'
 
 const JOIN_REFUSALS: Record<Extract<WallJoinResult, { ok: false }>['reason'], string> = {
   'covered-existing-wall': 'An existing wall already covers this span',

package/src/lib/floorplan/schedules.ts

@@ -1,8 +1,11 @@
 import type { AnyNode, AnyNodeId, DoorNode, WallNode, WindowNode, ZoneNode } from '@pascal-app/core'
-import { deriveZoneQuantityReport, resolveHostedOpeningFrameDepth } from '@pascal-app/core'
+import {
+  deriveZoneQuantityReport,
+  type FloorplanSchedule,
+  resolveHostedOpeningFrameDepth,
+  resolveMarkDetail,
+} from '@pascal-app/core'
 import { collectFloorplanSchedules } from './floorplan-export'
-import type { FloorplanSchedule } from './floorplan-extension'
-import { resolveMarkDetail } from './marks'
 
 /**
  * Construction-document schedule DATA — WS3.

package/src/lib/floorplan/sheet-export.ts

@@ -30,7 +30,11 @@ import type {
   FloorplanGeometry,
   LiveNodeOverrides,
 } from '@pascal-app/core'
-import { nodeRegistry, resolveBuildingForLevel } from '@pascal-app/core'
+import {
+  type FloorplanMetricNotation,
+  nodeRegistry,
+  resolveBuildingForLevel,
+} from '@pascal-app/core'
 import {
   buildContext,
   collectFloorplanLinkedLevelNodes,
@@ -52,14 +56,12 @@ import {
   resolveFloorplanExportRotationDeg,
   resolveFloorplanExportViewState,
 } from './floorplan-export'
-import type { FloorplanMetricNotation } from './floorplan-extension'
 import { createFloorplanPdfDocument } from './floorplan-pdfkit-document'
 import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
 
 /** PDF user-space units per inch. */
 export const POINTS_PER_INCH = 72
 
-export type { FloorplanSchedule } from './floorplan-extension'
 /**
  * The schedules the kinds on a level contribute
  * (`def.extensions['pascal:editor/floorplan'].schedule`). Re-exported here so
@@ -316,3 +318,5 @@ async function drawPlate(
     },
   )
 }
+
+export type { FloorplanSchedule } from '@pascal-app/core'

package/src/lib/floorplan/site-plan/site-parts.ts

@@ -15,7 +15,9 @@ import {
   isOutdoorRoomType,
   type LevelNode,
   migrateSiteMetadata,
+  type RoofNode,
   type RoofSegmentNode,
+  roofFaceShapes,
   type SceneSnapshot,
   type SiteNode,
   siteFrame,
@@ -75,7 +77,8 @@ export function findLowestLevel(
 /**
  * The roof's outline on the lot — every roof segment's plan rectangle out to
  * its deck's reach at its eaves and rakes, through the segment's, the roof's
- * and the building's turns, unioned into the outer ring(s). Dashed on the site plan: what the eye sees
+ * and the building's turns, and every face of another kind (`capabilities.roofs`)
+ * by its own outline, unioned into the outer ring(s). Dashed on the site plan: what the eye sees
  * from above is the roof, and the setback is measured to the wall under it.
  */
 export function roofOutlineRings(
@@ -93,6 +96,9 @@ export function roofOutlineRings(
   }
   if (roofs.size === 0) return []
   const rects: Pt[][] = []
+  for (const roof of roofs.values())
+    for (const face of roofFaceShapes(roof as RoofNode, scene.nodes))
+      rects.push(face.outline.map(([x, z]) => toSite(x, z)))
   for (const node of Object.values(scene.nodes)) {
     if (node.type !== 'roof-segment') continue
     const roof = roofs.get(String((node as { parentId?: unknown }).parentId))

package/src/lib/floorplan/site-plan/site-plan-layer.tsx

@@ -7,8 +7,8 @@ import {
   resumeSceneHistory,
   useScene,
 } from '@pascal-app/core'
+import { FloorplanGeometryRenderer } from '@pascal-app/viewer/ui'
 import { type PointerEvent as ReactPointerEvent, useCallback, useMemo, useRef } from 'react'
-import { FloorplanGeometryRenderer } from '../../../components/editor-2d/renderers/floorplan-geometry-renderer'
 import { clientToPlan } from '../plan-coords'
 import { buildSitePlanDrawing } from './build-site-plan-drawing'
 

package/src/lib/follow-pascal-presentation.ts

@@ -1,5 +1,5 @@
 import type { WallMode } from '@pascal-app/viewer'
-import type { RoomKey } from './room-selection'
+import type { RoomKey } from '@pascal-app/viewer/ui'
 
 /**
  * Follow Pascal changes how the building is shown so the build it follows is in view: the walls cut

package/src/lib/gesture-lifecycle.ts

@@ -33,7 +33,9 @@ export type GestureSpec = {
   kind: string
   /**
    * Drops the gesture's own in-flight state (draft, preview, listeners,
-   * pending frames). Never writes the scene. Runs once, on cancel only.
+   * pending frames). Runs once, on cancel only. Undo and redo cancel before
+   * they jump, so this must record no history: a gesture that previews
+   * through scene writes under paused history reverts them here, then resumes.
    */
   onCancel: (reason: GestureCancelReason) => void
   /** A scope the owner begins for the gesture and releases only while it is still this one. */

package/src/lib/glb-export.ts

@@ -32,6 +32,7 @@ import {
   type ViewerPresentationContribution,
   viewerPresentationRegistry,
 } from '@pascal-app/viewer'
+import { nodeDisplayLabel } from '@pascal-app/viewer/ui'
 import type { Object3D } from 'three'
 import * as THREE from 'three'
 import {
@@ -42,7 +43,6 @@ import {
 import { createExportTextureUtils, type ExportTextureUtils } from './export-texture-utils'
 import { cloneExportUserData } from './export-user-data'
 import { isIfcRolePart } from './ifc-parts'
-import { nodeDisplayLabel } from './node-display-label'
 import {
   type CompressedTextureDecompressor,
   decompressCanonicalNormalMaps,

package/src/lib/interaction/scope.ts

@@ -28,6 +28,7 @@ export type ReshapeKind =
   | 'tangent'
   // A kind's own reshape (wall 'split'): mounted from `def.affordanceTools[reshape]`.
   | 'split'
+  | 'trim'
 
 export type InteractionScope =
   | { kind: 'idle' }

package/src/lib/layer-thickness.ts

@@ -1,4 +1,4 @@
-import type { LinearUnit } from './measurements'
+import type { LinearUnit } from '@pascal-app/core'
 
 const METRES_PER_INCH = 0.0254
 

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

@@ -3,6 +3,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   BuildingNode,
+  ElevatorNode,
   LevelNode,
   RoofNode,
   useScene,
@@ -27,10 +28,14 @@ beforeEach(() => {
     metadata: { role: 'roof' },
   })
   const roof = RoofNode.parse({ id: 'roof_main', parentId: roofLevel.id })
-  const building = BuildingNode.parse({ id: BUILDING, children: [GROUND, roofLevel.id] })
+  const elevator = ElevatorNode.parse({ id: 'elevator_lift', parentId: BUILDING })
+  const building = BuildingNode.parse({
+    id: BUILDING,
+    children: [GROUND, roofLevel.id, elevator.id],
+  })
   useScene.setState({
     nodes: Object.fromEntries(
-      [building, ground, wall, roofLevel, roof].map((node) => [node.id, node as AnyNode]),
+      [building, ground, wall, roofLevel, roof, elevator].map((node) => [node.id, node as AnyNode]),
     ),
     rootNodeIds: [BUILDING],
   } as never)
@@ -54,4 +59,15 @@ describe('selectPlacedNode', () => {
       selectedIds: ['wall_a'],
     })
   })
+
+  test('a building-parented node keeps the floor in view and adopts its building', () => {
+    useViewer.getState().resetSelection()
+    useViewer.getState().setSelection({ levelId: GROUND })
+    selectPlacedNode('elevator_lift' as AnyNodeId)
+    expect(useViewer.getState().selection).toMatchObject({
+      buildingId: BUILDING,
+      levelId: GROUND,
+      selectedIds: ['elevator_lift'],
+    })
+  })
 })

package/src/lib/level-selection.ts

@@ -1,4 +1,4 @@
-import type { AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
+import type { AnyNode, AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
 import { findLevelAncestorId, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 
@@ -30,17 +30,40 @@ export function deleteLevelWithFallbackSelection(levelId: AnyNodeId) {
   }
 }
 
+function findBuildingAncestorId(
+  nodeId: AnyNodeId,
+  nodes: Record<string, AnyNode>,
+): BuildingNode['id'] | null {
+  let current: AnyNode | undefined = nodes[nodeId]
+  for (let guard = 0; current && guard < 16; guard++) {
+    if (current.type === 'building') return current.id
+    current = current.parentId ? nodes[current.parentId as AnyNodeId] : undefined
+  }
+  return null
+}
+
 /**
  * Selects a node a tool just made, on its own level when that is not the one in view: a roof drawn
  * over a storey's walls lands on the level above, which the editor hides while the storey is
- * selected, so selecting it there alone would leave it out of sight.
+ * selected, so selecting it there alone would leave it out of sight. A node parented to the
+ * building itself (an elevator) has no level, so the floor in view stays active when it belongs
+ * to that building.
  */
 export function selectPlacedNode(nodeId: AnyNodeId) {
-  const levelId = findLevelAncestorId(nodeId, useScene.getState().nodes)
+  const { nodes } = useScene.getState()
+  const levelId = findLevelAncestorId(nodeId, nodes) as LevelNode['id'] | null
+  const buildingId = findBuildingAncestorId(nodeId, nodes)
   const { selection, setSelection } = useViewer.getState()
-  setSelection(
-    levelId && levelId !== selection.levelId
-      ? { levelId: levelId as LevelNode['id'], selectedIds: [nodeId] }
-      : { selectedIds: [nodeId] },
-  )
+  const updates: Partial<typeof selection> = { selectedIds: [nodeId] }
+  if (buildingId && buildingId !== selection.buildingId) {
+    updates.buildingId = buildingId
+    updates.levelId =
+      levelId ??
+      (selection.levelId && findBuildingAncestorId(selection.levelId, nodes) === buildingId
+        ? selection.levelId
+        : null)
+  } else if (levelId && levelId !== selection.levelId) {
+    updates.levelId = levelId
+  }
+  setSelection(updates)
 }

package/src/lib/linear-display.ts

@@ -4,7 +4,7 @@ import {
   linearUnitToMeters,
   type MetricNotation,
   metersToLinearUnit,
-} from './measurements'
+} from '@pascal-app/core'
 
 export function getLinearDisplay(
   unit: string,

package/src/lib/live-gesture-round-trip.test.ts

@@ -6,6 +6,7 @@ import {
   createZoneDivisionContext,
   generateId,
   nodeRegistry,
+  roomFloorElevation,
   type SlabNode,
   useLiveNodeOverrides,
   useScene,
@@ -29,7 +30,6 @@ import { roomRelativeFloorHeight, stepRoomFloorElevation } from './room-construc
 import {
   commitRoomElevation,
   mezzanineEdgeHandles,
-  roomFloorElevation,
   roomPushHandles,
   runFloorplanMezzanineEdge,
   runFloorplanRoomPush,

package/src/lib/material-paint.ts

@@ -309,7 +309,7 @@ export function resolveActivePaintMaterialFromSelection(params: {
     ) {
       const roofNode = selectedNode as RoofNode
       const fallbackSegment = (roofNode.children ?? [])
-        .map((id: AnyNodeId) => nodes[id as AnyNodeId] as RoofSegmentNode | undefined)
+        .map((id) => nodes[id as AnyNodeId] as RoofSegmentNode | undefined)
         .find(
           (segment: RoofSegmentNode | undefined) =>
             segment?.type === 'roof-segment' &&

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import { measurementCentroid, pointInPolygon2D } from '@pascal-app/core'
-import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from './measurement-label'
+import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from '@pascal-app/viewer'
 
 describe('measurementPolygonLabelAnchor', () => {
   test('keeps a concave polygon label inside its visible fill', () => {

package/src/lib/measurements.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test } from 'bun:test'
-import { measurementHint, parseMeasurement } from '../index'
 import {
   buildMeasurementAngleArcPoints,
   cubicMetersToVolumeUnit,
@@ -11,16 +10,19 @@ import {
   getVolumeUnitLabel,
   linearControlValueToMeters,
   linearUnitToMeters,
+  metersToLinearUnit,
+  parseLinearMeasurementInput,
+  squareMetersToAreaUnit,
+} from '@pascal-app/core'
+import {
   MEASUREMENT_ACTIVE_COLOR,
   MEASUREMENT_DANGLING_COLOR,
   MEASUREMENT_FLOORPLAN_COLOR,
   MEASUREMENT_PERSISTENT_COLOR,
   measurementFloorplanPresentationColor,
   measurementPresentationColor,
-  metersToLinearUnit,
-  parseLinearMeasurementInput,
-  squareMetersToAreaUnit,
-} from './measurements'
+} from '@pascal-app/viewer'
+import { measurementHint, parseMeasurement } from '../index'
 
 describe('measurement presentation', () => {
   test('uses black at rest, indigo while active, and red for dangling references', () => {

package/src/lib/mezzanine-selection.test.ts

@@ -15,6 +15,7 @@ import {
   type ZoneNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { RoomSelectionIndex, resolveRoomHit } from '@pascal-app/viewer/ui'
 import { deleteConfirmationContent } from '../components/editor/delete-confirmation-dialog'
 import { resolveFloorRegionRoom } from '../components/editor/floor-region-controls'
 import { MEZZANINE_GESTURE_HINTS, mezzanineGesture } from '../components/ui/helpers/helper-manager'
@@ -23,7 +24,6 @@ import {
   mezzanineElevationBounds,
   ROOM_ELEVATION_DRAG_LABEL,
 } from './room-handle-drag'
-import { RoomSelectionIndex, resolveRoomHit } from './room-selection'
 import { applyRoomPlan } from './room-structure-commands'
 import { ROOM_MOVE_DRAG_LABEL } from './room-transform-session'
 import { zoneAtLevelPoint } from './units'

package/src/lib/node-action-movement.test.tsx

@@ -0,0 +1,115 @@
+import { beforeAll, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  isMoveLocked,
+  isNodeDuplicable,
+  nodeRegistry,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import { duplicateNodeAndPickUp } from '../components/editor/duplicate-node'
+import { classifyParticipant } from '../components/editor/group-transform-shared'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import { canDirectMoveNode } from './direct-manipulation'
+import { createEditorApi } from './editor-api'
+import { registryMoveDisabled } from './node-action-movement'
+import { copySelectedNodesToEditorClipboard } from './scene-clipboard'
+
+// Mirrors a lean-to post: a kind-level 2D mover plus per-node move and duplicate locks.
+const KIND = 'move-lock-test'
+
+beforeAll(() => {
+  if (nodeRegistry.has(KIND)) return
+  registerNode({
+    kind: KIND,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(KIND) }) as never,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: {
+      movable: {
+        axes: ['x', 'z'],
+        gridSnap: true,
+        override: ({ node }) =>
+          (node as { metadata?: { locked?: boolean } }).metadata?.locked
+            ? { axes: [], gridSnap: false }
+            : null,
+      },
+      duplicable: {
+        allow: ({ node }) => !(node as { metadata?: { locked?: boolean } }).metadata?.locked,
+      },
+    },
+    floorplanMoveTarget: () => ({
+      affectedIds: [],
+      apply() {},
+      canCommit: () => false,
+      commit() {},
+    }),
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+})
+
+function node(locked: boolean) {
+  return {
+    id: locked ? 'move_lock_locked' : 'move_lock_free',
+    type: KIND,
+    parentId: 'level_move_lock',
+    position: [1, 0, 2],
+    rotation: 0,
+    metadata: locked ? { locked: true } : {},
+  } as unknown as AnyNode
+}
+
+test('a per-node override lock outranks the kind-level 2D mover', () => {
+  expect(isMoveLocked(node(true))).toBe(true)
+  expect(isMoveLocked(node(false))).toBe(false)
+  expect(registryMoveDisabled(node(true))).toBe(true)
+  expect(registryMoveDisabled(node(false))).toBe(false)
+  expect(canDirectMoveNode(node(true))).toBe(false)
+})
+
+test('group pick-up leaves a locked node behind', () => {
+  const locked = node(true)
+  const free = node(false)
+  const nodes = { [locked.id]: locked, [free.id]: free }
+  expect(classifyParticipant(locked, 'level_move_lock', nodes)).toBeNull()
+  expect(classifyParticipant(free, 'level_move_lock', nodes)).toBe('scalar')
+})
+
+test('every moving-node entry refuses a locked node', () => {
+  const api = createEditorApi()
+  useEditor.getState().setMovingNode(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  api.engageMoveDrag(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(useEditor.getState().placementDragMode).toBe(false)
+  api.engageMove(node(false))
+  expect(useInteractionScope.getState().scope.kind).toBe('moving')
+  useEditor.getState().setMovingNode(null)
+})
+
+test('a locked node cannot be duplicated or copied', () => {
+  const level = {
+    id: 'level_move_lock',
+    type: 'level',
+    parentId: null,
+    children: ['move_lock_locked', 'move_lock_free'],
+  } as unknown as AnyNode
+  const locked = node(true)
+  const free = node(false)
+  useScene.setState({
+    nodes: { [level.id]: level, [locked.id]: locked, [free.id]: free } as never,
+    rootNodeIds: [level.id as AnyNodeId],
+  })
+  expect(isNodeDuplicable(locked)).toBe(false)
+  expect(isNodeDuplicable(free)).toBe(true)
+  duplicateNodeAndPickUp(locked)
+  expect(Object.keys(useScene.getState().nodes)).toHaveLength(3)
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(copySelectedNodesToEditorClipboard([locked.id as AnyNodeId])).toBe(false)
+  expect(copySelectedNodesToEditorClipboard([free.id as AnyNodeId])).toBe(true)
+})

package/src/lib/node-action-movement.ts

@@ -4,12 +4,14 @@ import {
   cloneNodesInto,
   collectSubtree,
   isMovable,
+  isMoveLocked,
   nodeRegistry,
   useScene,
 } from '@pascal-app/core'
 import { copyCreateOps } from './fresh-planar-placement'
 
 export function registryMoveDisabled(node: AnyNode): boolean {
+  if (isMoveLocked(node)) return true
   const def = nodeRegistry.get(node.type)
   return Boolean(
     def?.capabilities.movable &&

package/src/lib/paint-region-mode.ts

@@ -1,6 +1,6 @@
+import { isTypingTarget } from '@pascal-app/viewer'
 import { create } from 'zustand'
 import type { ActivePaintMaterial } from './material-paint'
-import { isTypingTarget } from './typing-target'
 
 /**
  * What a paint click does: paint the whole surface under it, draw part of a

package/src/lib/placement-metadata.ts

@@ -17,6 +17,10 @@ export function isFreshPlacementMetadata(metadata: unknown): boolean {
   return getPlacementMetadataRecord(metadata).isNew === true
 }
 
+export function stripPlacementMetadataFlags(
+  metadata: Record<string, unknown>,
+): Record<string, unknown>
+export function stripPlacementMetadataFlags(metadata: unknown): unknown
 export function stripPlacementMetadataFlags(metadata: unknown): unknown {
   if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
     return metadata