@pascal-app/editor 1.0.6 → 1.1.0

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@pascal-app/editor",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Pascal building editor component",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": "./src/index.tsx",
     "./catalog": "./src/components/ui/item-catalog/catalog-items.tsx",
+    "./locales": "./src/i18n/locales.ts",
+    "./locales/pseudo": "./src/i18n/pseudo-locale.ts",
     "./procedural-items": "./src/components/procedural-items/inspector.tsx",
     "./distribution": "./src/components/tools/distribution/distribution-public.ts"
   },
@@ -16,23 +18,24 @@
     "test": "bun test src"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.6",
-    "@pascal-app/viewer": "^1.0.6",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "next": ">=15",
     "react": "^18 || ^19",
     "react-dom": "^18 || ^19",
-    "three": "^0.186"
+    "three": "^0.187"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "@iconify/react": "^6.0.3",
+    "@iconify/react": "^6.0.4",
+    "@lingui/core": "6.12.0",
     "@number-flow/react": "^0.6.2",
-    "@pascal-app/geometry-script": "^1.0.6",
-    "@pascal-app/ifc-converter": "^1.0.6",
+    "@pascal-app/geometry-script": "^1.1.0",
+    "@pascal-app/ifc-converter": "^1.1.0",
     "@pascal-app/lingo": "^0.5.0",
     "@radix-ui/react-alert-dialog": "^1.2.1",
     "@radix-ui/react-context-menu": "^2.4.1",
@@ -53,31 +56,31 @@
     "cmdk": "^1.1.1",
     "fflate": "^0.8.3",
     "howler": "^2.2.4",
-    "lucide-react": "^1.61.0",
+    "lucide-react": "^1.69.0",
     "manifold-3d": "3.5.4",
     "mitt": "^3.0.1",
-    "motion": "^14.6.0",
+    "motion": "^14.9.1",
     "nanoid": "^6.0.2",
     "pdfkit": "^0.20.2",
     "tailwind-merge": "^3.7.0",
     "three-bvh-csg": "^0.0.18",
-    "three-mesh-bvh": "~0.9.16",
+    "three-mesh-bvh": "~0.9.18",
     "zod": ">=4.6.7 <4.7",
     "zustand": "^5.0.16"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.6",
-    "@pascal-app/viewer": "^1.0.6",
+    "@pascal-app/core": "^1.1.0",
+    "@pascal-app/viewer": "^1.1.0",
     "@pascal/typescript-config": "*",
     "@react-three/test-renderer": "^9.1.1",
     "@types/blob-stream": "^0.1.33",
-    "@types/bun": "^1.4.3",
+    "@types/bun": "^1.4.4",
     "@types/howler": "^2.2.13",
     "@types/pdfkit": "^0.17.7",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
-    "@types/three": "^0.186.0",
-    "fast-xml-parser": "^5.11.2",
+    "@types/three": "^0.187",
+    "fast-xml-parser": "^5.12.0",
     "typescript": "7.0.2"
   },
   "repository": {

package/src/components/editor/action-menu-button.tsx

@@ -1,6 +1,8 @@
 'use client'
 
+import { usePascalI18n } from '@pascal-app/core'
 import type { MouseEventHandler, ReactNode } from 'react'
+import { toolHintKey } from '../../i18n/node-messages'
 import { cn } from '../../lib/utils'
 import { shortcutDisplayValue } from '../ui/primitives/shortcut-token'
 import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/primitives/tooltip'
@@ -37,6 +39,7 @@ export function ActionMenuButton({
   pressed?: boolean
   children: ReactNode
 }) {
+  const i18n = usePascalI18n()
   return (
     <Tooltip>
       <TooltipTrigger asChild>
@@ -72,7 +75,7 @@ export function ActionMenuButton({
                 className="rounded border border-background/30 px-1 font-mono text-[10px] leading-4 opacity-80"
                 key={key}
               >
-                {shortcutDisplayValue(key)}
+                {toolHintKey(shortcutDisplayValue(key), i18n)}
               </kbd>
             ))}
           </span>

package/src/components/editor/alignment-3d-guide-layer.tsx

@@ -2,13 +2,16 @@
 
 import { type AlignmentGuide, sceneRegistry } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame } from '@react-three/fiber'
 import { memo, useMemo, useRef } from 'react'
-import { BoxGeometry, CircleGeometry, type Group, Vector3 } from 'three'
+import { BoxGeometry, CircleGeometry, type Group, RingGeometry, Vector3 } from 'three'
 import { MeshBasicNodeMaterial } from 'three/webgpu'
 import { EDITOR_LAYER } from '../../lib/constants'
-import useAlignmentGuides from '../../store/use-alignment-guides'
+import useAlignmentGuides, {
+  type DraftGuideLine,
+  type DraftGuides,
+} from '../../store/use-alignment-guides'
+import { Html } from './localized-html'
 import { formatMeasurement } from './measurement-pill'
 
 /**
@@ -22,13 +25,18 @@ import { formatMeasurement } from './measurement-pill'
  * the design reference — so they're real 3D geometry, not screen billboards.
  * Only the distance pill is screen-space (`<Html>`).
  *
- * Guide coordinates are XZ meters in the WORLD frame — alignment now resolves
- * on the world axes (via `resolveAlignmentForActiveBuilding`) so the guides
- * stay parallel to the visible world grid even when the active building is
- * rotated. This layer is mounted OUTSIDE the building-local ToolManager group
- * for the same reason. The whole ribbon is lifted to the active level's WORLD
- * Y each frame so it lies on the floor being edited — not the building base —
- * when floors are stacked.
+ * Guide coordinates are XZ meters in the active building's LOCAL frame —
+ * alignment resolves on the building's own axes, the axes its 3D grid is laid
+ * on — and the layer is mounted inside the building-local ToolManager group.
+ * The whole ribbon is lifted to the active level's WORLD Y each frame so it
+ * lies on the floor being edited — not the building base — when floors are
+ * stacked.
+ *
+ * A wall pulled from a wall end (and the run it continues) publishes its
+ * projection guides beside them (`useAlignmentGuides.draft`): the extension of
+ * the wall it comes from in amber, lines through other walls' ends in indigo,
+ * lines through the run's start in emerald, all dashed, with a ringed marker
+ * where two of them cross.
  */
 
 const LINE_COLOR = 0x81_8c_f8 // indigo-400 — matches the editor's selection accent (box-select / wall highlights)
@@ -59,11 +67,33 @@ const dotMaterial = new MeshBasicNodeMaterial({
 })
 const DASH_GEOMETRY = new BoxGeometry(1, 1, 1)
 const DOT_GEOMETRY = new CircleGeometry(1, 24)
+const RING_GEOMETRY = new RingGeometry(0.7, 1, 28)
+
+// Draft projection guides: one material per kind, shared like the above.
+const draftGuideMaterial = (color: number) =>
+  new MeshBasicNodeMaterial({
+    color,
+    depthTest: false,
+    depthWrite: false,
+    toneMapped: false,
+    transparent: true,
+    opacity: 0.9,
+  })
+const DRAFT_GUIDE_MATERIALS: Record<DraftGuideLine['kind'], MeshBasicNodeMaterial> = {
+  extension: draftGuideMaterial(0xf5_9e_0b), // amber-500
+  alignment: guideMaterial,
+  'run-start': draftGuideMaterial(0x10_b9_81), // emerald-500 — the pull grip's colour
+}
+const DRAFT_DASH_LEN = 0.14
+const DRAFT_DASH_GAP = 0.12
+const DRAFT_LINE_WIDTH = 0.035
+const INTERSECTION_RADIUS = 0.13
 
 type Vec3 = [number, number, number]
 
 export const Alignment3DGuideLayer = memo(function Alignment3DGuideLayer() {
   const guides = useAlignmentGuides((s) => s.guides)
+  const draft = useAlignmentGuides((s) => s.draft)
   const levelId = useViewer((s) => s.selection.levelId)
   const unit = useViewer((s) => s.unit)
   const metricNotation = useViewer((s) => s.metricNotation)
@@ -82,16 +112,77 @@ export const Alignment3DGuideLayer = memo(function Alignment3DGuideLayer() {
     group.position.y = levelMesh ? levelMesh.getWorldPosition(worldYWork).y : 0
   })
 
-  if (guides.length === 0) return null
+  if (guides.length === 0 && !draft) return null
   return (
     <group ref={groupRef}>
       {guides.map((guide, i) => (
         <GuideLine guide={guide} key={i} metricNotation={metricNotation} unit={unit} />
       ))}
+      {draft ? <DraftGuidesLayer draft={draft} /> : null}
     </group>
   )
 })
 
+/** A wall draft's dashed projection guides and the markers where they cross. */
+function DraftGuidesLayer({ draft }: { draft: DraftGuides }) {
+  return (
+    <>
+      {draft.lines.map((line, i) => (
+        <DraftLine key={`l${i}`} line={line} />
+      ))}
+      {draft.intersections.map((point, i) => (
+        <mesh
+          geometry={RING_GEOMETRY}
+          key={`x${i}`}
+          layers={EDITOR_LAYER}
+          material={guideMaterial}
+          position={[point[0], GUIDE_Y + 0.002, point[1]]}
+          renderOrder={1001}
+          rotation={[-Math.PI / 2, 0, 0]}
+          scale={[INTERSECTION_RADIUS, INTERSECTION_RADIUS, INTERSECTION_RADIUS]}
+        />
+      ))}
+    </>
+  )
+}
+
+function DraftLine({ line }: { line: DraftGuideLine }) {
+  const [fx, fz] = line.from
+  const [tx, tz] = line.to
+  const { dashes, angleY } = useMemo(() => {
+    const dx = tx - fx
+    const dz = tz - fz
+    const length = Math.hypot(dx, dz)
+    const angle = -Math.atan2(dz, dx)
+    if (length < 1e-4) return { dashes: [] as Vec3[], angleY: angle }
+    const ux = dx / length
+    const uz = dz / length
+    const period = Math.max(DRAFT_DASH_LEN + DRAFT_DASH_GAP, length / MAX_DASHES)
+    const centres: Vec3[] = []
+    for (let d = period / 2; d - DRAFT_DASH_LEN / 2 <= length; d += period) {
+      centres.push([fx + ux * d, GUIDE_Y, fz + uz * d])
+    }
+    return { dashes: centres, angleY: angle }
+  }, [fx, fz, tx, tz])
+  const material = DRAFT_GUIDE_MATERIALS[line.kind]
+  return (
+    <>
+      {dashes.map((centre, i) => (
+        <mesh
+          geometry={DASH_GEOMETRY}
+          key={i}
+          layers={EDITOR_LAYER}
+          material={material}
+          position={centre}
+          renderOrder={1000}
+          rotation={[0, angleY, 0]}
+          scale={[DRAFT_DASH_LEN, 0.002, DRAFT_LINE_WIDTH]}
+        />
+      ))}
+    </>
+  )
+}
+
 function GuideLine({
   guide,
   metricNotation,

package/src/components/editor/bake-thumbnail.tsx

@@ -47,8 +47,9 @@ const THUMBNAIL_BACKDROP = { inner: '#FAFAFA', outer: '#E4E4E4' }
 const THUMBNAIL_SHADOW_CATCHER_OPACITY = 0.7
 /** Soft shade hugging the ground-floor walls so the building never floats. */
 const THUMBNAIL_WALL_CONTACT = { opacity: 0.5, spreadM: 0.9 }
-/** Unpainted walls render as smooth plaster rather than the screw-dotted
- *  prepared-drywall default, which reads as unfinished at card size. */
+/** A roof's unpainted trim and gable bands render as smooth plaster rather
+ *  than the screw-dotted prepared-drywall default, which reads as unfinished
+ *  at card size. Unpainted walls already wear the interior paint. */
 const THUMBNAIL_SLOT_DEFAULT_OVERRIDES = {
   'library:concrete-drywall': 'library:concrete-plaster',
 } as const

package/src/components/editor/custom-camera-controls.tsx

@@ -29,6 +29,7 @@ import {
   type Camera,
   type OrthographicCamera,
   type PerspectiveCamera,
+  Sphere,
   Spherical,
   Vector3,
 } from 'three'
@@ -62,6 +63,7 @@ import {
   orbitFloorMinY,
   overviewEyeY,
 } from '../../lib/orbit-floor-clearance'
+import { orbitNearPlane } from '../../lib/orbit-near-plane'
 import { editorOwnsOneFingerDrag } from '../../lib/touch-gesture-priority'
 import { frameViewerCamera } from '../../lib/viewer-selection'
 import { publishCameraPose } from '../../store/camera-pose-store'
@@ -73,6 +75,13 @@ import {
 } from '../../store/use-interaction-scope'
 import { visibleScene } from '../../store/view-layout'
 import { createCameraDraggingLifecycle } from './camera-dragging-lifecycle'
+import {
+  type FitSceneLookAt,
+  type PendingFitScene,
+  planFitSceneOnEvent,
+  planFitSceneOnOrbitResume,
+  planLevelFollow,
+} from './fit-scene-framing'
 import { FloorAwareCameraControls } from './floor-aware-camera-controls'
 import { FloorSurface } from './floor-surface'
 
@@ -83,6 +92,7 @@ const tempDelta = new Vector3()
 const tempPosition = new Vector3()
 const tempSize = new Vector3()
 const tempTarget = new Vector3()
+const fitSceneSphere = new Sphere()
 const transitionFreezePosition = new Vector3()
 const transitionFreezeTarget = new Vector3()
 const keyboardPanSpherical = new Spherical()
@@ -119,6 +129,23 @@ function keepEyeOverGround(x: number, eyeY: number, z: number, previousEyeY = ey
   return overviewEyeY(eyeY, previousEyeY, groundY, useViewer.getState().eyeUnderGround)
 }
 
+function applyFitLookAt(control: CameraControlsImpl, lookAt: FitSceneLookAt) {
+  control.setLookAt(
+    lookAt.eyeX,
+    keepEyeOverGround(lookAt.eyeX, lookAt.eyeY, lookAt.eyeZ, lookAt.eyeHeight),
+    lookAt.eyeZ,
+    lookAt.targetX,
+    lookAt.targetY,
+    lookAt.targetZ,
+    true,
+  )
+  if (isOrthographicCamera(control.camera)) {
+    fitSceneSphere.center.set(...lookAt.fitSphere.center)
+    fitSceneSphere.radius = lookAt.fitSphere.radius
+    control.fitToSphere(fitSceneSphere, true)
+  }
+}
+
 function levelOf(nodeId: string): string | null {
   const nodes = useScene.getState().nodes
   let node: AnyNode | undefined = nodes[nodeId as AnyNodeId]
@@ -406,6 +433,9 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
   if (selection.levelId) lastLevelId.current = selection.levelId
   const currentLevelId = lastLevelId.current
   const firstLoad = useRef(true)
+  // Survives first-person (orbit unmounted) so scene-ready fit still applies
+  // once CameraControls remount.
+  const pendingFitSceneRef = useRef<PendingFitScene | null>(null)
   const floorY = useScene((state) =>
     currentLevelId ? getLevelPresentationY(currentLevelId, state.nodes, levelMode) : 0,
   )
@@ -614,19 +644,32 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     }
   }, [scene, gl, camera])
 
+  const previousLevelIdRef = useRef<string | null>(null)
+  const previousLevelModeRef = useRef(levelMode)
+  const previousCameraRef = useRef(camera)
   // `camera` too: drei builds a fresh controls instance (pivot at the origin)
   // when the default camera mounts or changes; it is rested on the floor too.
-  // biome-ignore lint/correctness/useExhaustiveDependencies: camera re-runs this on a new instance
   useEffect(() => {
     if (isPreviewMode || isFirstPersonMode || isRestoringFirstPersonPose()) return
     // Analytic destination, not `sceneRegistry` mesh position: a level created
     // this frame still sits at y=0 (LevelSystem lerps it later), and a mode
-    // switch leaves every level mid-lerp — the camera must pan to where the
+    // switch leaves every level mid-lerp - the camera must pan to where the
     // level will settle, in the CURRENT presentation mode.
     const targetY = orbitGroundY(currentLevelId, levelMode)
     if (!controls.current) return
-    if (firstLoad.current) {
-      firstLoad.current = false
+    const plan = planLevelFollow({
+      firstLoad: firstLoad.current,
+      sceneEmpty: Object.keys(useScene.getState().nodes).length === 0,
+      levelChanged: previousLevelIdRef.current !== currentLevelId,
+      modeChanged: previousLevelModeRef.current !== levelMode,
+      cameraChanged: previousCameraRef.current !== camera,
+    })
+    firstLoad.current = false
+    previousLevelIdRef.current = currentLevelId
+    previousLevelModeRef.current = levelMode
+    previousCameraRef.current = camera
+    if (plan === 'none') return
+    if (plan === 'default-pose') {
       controls.current.setLookAt(
         20,
         keepEyeOverGround(20, 20 + targetY, 20, 20),
@@ -636,6 +679,7 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
         0,
         true,
       )
+      return
     }
     controls.current.getOrbitTarget(currentTarget)
     // Idempotence guard: skip when already there — also swallows the thumbnail
@@ -691,6 +735,19 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     controls.current.floorSurface = diveFloor === null ? floorSurface : null
   }, [camera, currentLevelId, diveFloor, floorMinY, floorSurface, isFirstPersonMode])
 
+  const flushPendingFitScene = useCallback(() => {
+    const plan = planFitSceneOnOrbitResume({
+      isPreviewMode,
+      isFirstPersonMode: useEditor.getState().isFirstPersonMode,
+      hasControls: !!controls.current,
+      pending: pendingFitSceneRef.current,
+      groundY: orbitGroundY(lastLevelId.current),
+    })
+    if (plan.action !== 'apply' || !controls.current) return
+    pendingFitSceneRef.current = null
+    applyFitLookAt(controls.current, plan.lookAt)
+  }, [isPreviewMode])
+
   const focusNode = useCallback(
     (nodeId: string) => {
       if (isPreviewMode || isFirstPersonMode || !controls.current) return
@@ -766,8 +823,16 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
   }, [camera, isFirstPersonMode, viewportSize])
 
   const handleCameraUpdate = useCallback(() => {
+    const control = controls.current
+    if (control && isPerspectiveCamera(camera)) {
+      const near = orbitNearPlane(control.distance)
+      if (Math.abs(camera.near - near) > 1e-4) {
+        camera.near = near
+        camera.updateProjectionMatrix()
+      }
+    }
     publishCurrentPose()
-  }, [publishCurrentPose])
+  }, [camera, publishCurrentPose])
 
   useEffect(() => {
     publishInitialCameraPose(publishCurrentPose)
@@ -1054,7 +1119,10 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       updateNavigationCursor()
     }
 
-    const onWheel = () => {
+    const onWheel = (event: WheelEvent) => {
+      // Zooming in carries on past the closest orbit, the target with it; zooming out stops at
+      // the farthest, or the eye would drift off the site. Seen before the controls' own listener.
+      if (controls.current) controls.current.infinityDolly = event.deltaY < 0
       beginLocalCameraInteraction()
       cameraDraggingLifecycle.scheduleEnd()
     }
@@ -1376,37 +1444,22 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     }
 
     const handleFitScene = ({ bounds }: CameraControlFitSceneEvent) => {
-      if (isFirstPersonMode || !controls.current || isPreviewMode) return
-      const groundY = orbitGroundY(lastLevelId.current)
-      if (!bounds) {
-        // Restore default framing pose when no bounds were computed.
-        controls.current.setLookAt(
-          20,
-          keepEyeOverGround(20, 20 + groundY, 20, 20),
-          20,
-          0,
-          groundY,
-          0,
-          true,
-        )
+      const plan = planFitSceneOnEvent({
+        isPreviewMode,
+        isFirstPersonMode,
+        hasControls: !!controls.current,
+        bounds: bounds ?? null,
+        groundY: orbitGroundY(lastLevelId.current),
+      })
+      if (plan.action === 'ignore') return
+      if (plan.action === 'queue') {
+        pendingFitSceneRef.current = plan.pending
+        // Orbit path with a not-yet-attached ref: retry next frame.
+        if (!isFirstPersonMode) requestAnimationFrame(flushPendingFitScene)
         return
       }
-      const [cx, cz] = bounds.center
-      const [w, d] = bounds.size
-      // Use the longer horizontal extent to size the orbit radius so the whole
-      // footprint sits in view regardless of aspect ratio.
-      const maxExtent = Math.max(w, d)
-      const distance = Math.max(maxExtent * 1.4, 15)
-      const height = Math.max(maxExtent * 0.8, 10)
-      controls.current.setLookAt(
-        cx + distance * 0.7,
-        keepEyeOverGround(cx + distance * 0.7, height + groundY, cz + distance * 0.7, height),
-        cz + distance * 0.7,
-        cx,
-        groundY,
-        cz,
-        true,
-      )
+      pendingFitSceneRef.current = null
+      if (controls.current) applyFitLookAt(controls.current, plan.lookAt)
     }
 
     emitter.on('camera-controls:capture', handleNodeCapture)
@@ -1428,7 +1481,22 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       emitter.off('camera-controls:orbit-ccw', handleOrbitCCW)
       emitter.off('camera-controls:fit-scene', handleFitScene)
     }
-  }, [camera, cancelPoseApplication, focusNode, isPreviewMode, isFirstPersonMode])
+  }, [
+    camera,
+    cancelPoseApplication,
+    flushPendingFitScene,
+    focusNode,
+    isPreviewMode,
+    isFirstPersonMode,
+  ])
+
+  // Apply a fit that arrived while first-person (orbit unmounted). Wait one
+  // frame so CameraControls can remount and attach its ref.
+  useEffect(() => {
+    if (isFirstPersonMode || isPreviewMode || !pendingFitSceneRef.current) return
+    const frame = requestAnimationFrame(flushPendingFitScene)
+    return () => cancelAnimationFrame(frame)
+  }, [flushPendingFitScene, isFirstPersonMode, isPreviewMode])
 
   const onTransitionStart = useCallback(() => {
     cameraDraggingLifecycle.begin()
@@ -1452,13 +1520,12 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     }
   }, [cameraDraggingLifecycle])
 
-  // Preset capture mode frames a single subtree (often a 0.3–2m preset),
-  // so the default 2m minDistance prevents the user from getting close
-  // enough to compose a good thumbnail. Relax the clamp to 0.5m while
-  // capturing presets; reset on exit so general editing keeps the looser
-  // navigation guardrails.
+  // The wheel dollies toward the cursor and, at the closest orbit, carries the
+  // target on (infinity dolly), so the eye goes right up to a window's trim
+  // or through a doorway rather than stopping short of the orbit's pivot.
+  // Preset capture frames a single small subtree and orbits it closer still.
   const isPresetCapture = captureMode.mode === 'preset'
-  const minDistance = isPresetCapture ? 0.5 : 2
+  const minDistance = isPresetCapture ? 0.25 : 0.5
   // Over modeled or mapped surroundings (a neighbourhood instead of the
   // horizon disc) the camera may pull back far enough to take it all in.
   const groundReplaced = useSceneGroundReplacement()
@@ -1471,6 +1538,7 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
   return (
     <CameraControls
       azimuthRotateSpeed={ORBIT_ROTATE_SPEED}
+      dollyToCursor
       makeDefault
       maxDistance={maxDistance}
       impl={FloorAwareCameraControls}

package/src/components/editor/duplicate-node.ts

@@ -9,6 +9,7 @@ import {
   FenceNode,
   generateId,
   ItemNode,
+  isNodeDuplicable,
   nodeRegistry,
   RoofSegmentNode,
   runSceneHistoryDraftWrite,
@@ -48,7 +49,7 @@ export function copyCollectionIds(copy: AnyNode): CollectionId[] {
  * every inspector's Duplicate. The copy is in the collections its source is in.
  */
 export function duplicateNodeAndPickUp(node: AnyNode) {
-  if (!node.parentId) return
+  if (!(node.parentId && isNodeDuplicable(node))) return
   if (startZoneRoomTransform(node, 'duplicate')) return
   sfxEmitter.emit('sfx:item-pick')
   const { setMovingNode } = useEditor.getState()

package/src/components/editor/elevation-3d-guide-layer.tsx

@@ -2,13 +2,13 @@
 
 import { sceneRegistry } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame } from '@react-three/fiber'
 import { memo, useMemo, useRef } from 'react'
 import { BoxGeometry, CircleGeometry, type Group } from 'three'
 import { MeshBasicNodeMaterial } from 'three/webgpu'
 import { EDITOR_LAYER } from '../../lib/constants'
 import useElevationGuides from '../../store/use-elevation-guides'
+import { Html } from './localized-html'
 import { formatMeasurement } from './measurement-pill'
 
 const LINE_COLOR = 0x81_8c_f8