@pascal-app/editor 1.0.0 → 1.0.1

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@pascal-app/editor",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Pascal building editor component",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": "./src/index.tsx",
-    "./catalog": "./src/components/ui/item-catalog/catalog-items.tsx"
+    "./catalog": "./src/components/ui/item-catalog/catalog-items.tsx",
+    "./procedural-items": "./src/components/procedural-items/inspector.tsx"
   },
   "scripts": {
     "check-types": "tsgo --noEmit",
     "test": "bun test src"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.0",
-    "@pascal-app/viewer": "^1.0.0",
+    "@pascal-app/core": "^1.0.1",
+    "@pascal-app/viewer": "^1.0.1",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "next": ">=15",
@@ -61,8 +62,8 @@
     "zustand": "^5.0.11"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.0",
-    "@pascal-app/viewer": "^1.0.0",
+    "@pascal-app/core": "^1.0.1",
+    "@pascal-app/viewer": "^1.0.1",
     "@pascal/typescript-config": "*",
     "@react-three/test-renderer": "^9.1.0",
     "@types/blob-stream": "^0.1.33",

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

@@ -32,6 +32,10 @@ export function BakeExporter({
         const buffer = await exportSceneToGlb(sceneGroup, useScene.getState().nodes, {
           textures: 'reference',
           purpose: 'viewer',
+          // The bake worker owns the deadline (BAKE_CAPTURE_TIMEOUT_MS); under
+          // SwiftShader a moderate scene can legitimately outlast the
+          // interactive default.
+          timeoutMs: Number.POSITIVE_INFINITY,
         })
         onComplete(buffer)
       } catch (err) {

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

@@ -6,6 +6,7 @@ import {
   GRID_LAYER,
   heroCameraPose,
   temporarilyHideNodeTypes,
+  useSceneAtmosphere,
   useViewer,
 } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
@@ -25,6 +26,7 @@ export function BakeThumbnail({
 }) {
   const renderer = useThree((state) => state.gl)
   const scene = useThree((state) => state.scene)
+  const atmosphere = useSceneAtmosphere()
   const doneRef = useRef(false)
 
   useEffect(() => {
@@ -61,6 +63,7 @@ export function BakeThumbnail({
           renderer: renderer as unknown as WebGPURenderer,
           scene,
           camera,
+          atmosphere,
         })
         if (!pipeline) {
           onError('thumbnail pipeline failed to build')
@@ -89,7 +92,7 @@ export function BakeThumbnail({
     }
 
     void run()
-  }, [active, onComplete, onError, renderer, scene])
+  }, [active, atmosphere, onComplete, onError, renderer, scene])
 
   return null
 }

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

@@ -51,6 +51,7 @@ import {
 } from '../../lib/fresh-planar-placement'
 import { resolveFloatingActionMenuVisibility } from '../../lib/interaction/overlay-policy'
 import { curveReshapeScope, holeEditScope } from '../../lib/interaction/scope'
+import { duplicateWithoutMove, registryMoveDisabled } from '../../lib/node-action-movement'
 import { playBlockedQuickActionFeedback } from '../../lib/quick-action-feedback'
 import { collectQuickActionNodeScope } from '../../lib/quick-action-nodes'
 import { duplicateRoofSubtree } from '../../lib/roof-duplication'
@@ -501,6 +502,16 @@ export function FloatingActionMenu() {
       if (!node?.parentId) return
       sfxEmitter.emit('sfx:item-pick')
 
+      if (registryMoveDisabled(node)) {
+        try {
+          const id = duplicateWithoutMove(node)
+          if (id) setSelection({ selectedIds: [id] })
+        } catch (error) {
+          console.error('Failed to duplicate node', error)
+        }
+        return
+      }
+
       if (node.type === 'roof') {
         try {
           duplicateRoofSubtree(node.id as AnyNodeId, { mode: 'move' })
@@ -805,7 +816,9 @@ export function FloatingActionMenu() {
                   // `capabilities.movable`, a `floorplanMoveTarget`, or a
                   // 3D `affordanceTools.move` mover gets the Move button.
                   // Adding a new movable kind never touches this file.
-                  node && isRegistryMovable(node.type) ? handleMove : undefined
+                  node && isRegistryMovable(node.type) && !registryMoveDisabled(node)
+                    ? handleMove
+                    : undefined
                 }
                 onDelete={handleDelete}
                 onDuplicate={

package/src/components/editor/floorplan-panel.tsx

@@ -34,6 +34,7 @@ import {
   type RoofSegmentNode,
   resolveSlabPlacementElevation,
   resolveTerrainWallConstructionOptions,
+  runAsSingleSceneHistoryStep,
   type SiteNode,
   type SlabNode,
   SlabNode as SlabNodeSchema,
@@ -98,6 +99,7 @@ import { formatLinearMeasurement, linearUnitToMeters } from '../../lib/measureme
 import { sfxEmitter } from '../../lib/sfx-bus'
 import { SITE_BOUNDARY_DRAG_LABEL, siteBoundaryHandlesEnabled } from '../../lib/site-boundary'
 import { resolveSlabPlanPointSnap } from '../../lib/slab-plan-snap'
+import { cancelPendingZonePaint, focusedUnitNode, paintZoneMembership } from '../../lib/units'
 import { cn } from '../../lib/utils'
 import { snapBuildingLocalToWorldGrid } from '../../lib/world-grid-snap'
 import { subscribeNavigationSyncPose } from '../../store/navigation-sync-pose-store'
@@ -7952,7 +7954,7 @@ export function FloorplanPanel({
         return null
       }
 
-      const { createNode, nodes } = useScene.getState()
+      const { createNode, updateNode, nodes } = useScene.getState()
       const zoneCount = Object.values(nodes).filter((node) => node.type === 'zone').length
       const zone = ZoneNodeSchema.parse({
         color: PALETTE_COLORS[zoneCount % PALETTE_COLORS.length],
@@ -7960,9 +7962,15 @@ export function FloorplanPanel({
         polygon: points.map(([x, z]) => [x, z] as [number, number]),
       })
 
-      createNode(zone, levelId)
+      // Joining the focused unit rides in the zone's own undo step; selecting
+      // the zone would end focus, so a painted unit keeps it instead.
+      const focusedUnit = focusedUnitNode()
+      runAsSingleSceneHistoryStep(useScene, () => {
+        createNode(zone, levelId)
+        if (focusedUnit) updateNode(focusedUnit.id, { members: [...focusedUnit.members, zone.id] })
+      })
       sfxEmitter.emit('sfx:structure-build')
-      setSelection({ zoneId: zone.id })
+      if (!focusedUnit) setSelection({ zoneId: zone.id })
       return zone.id
     },
     [levelId, setSelection],
@@ -10008,6 +10016,18 @@ export function FloorplanPanel({
         setSelectedReferenceId(null)
 
         if (backgroundSelection.kind === 'select-zone') {
+          // Unit focus: a click paints membership, a double-click selects the
+          // zone and keeps focus (the SVG gets the second click as detail 2).
+          const focusedUnitId = useViewer.getState().focusedUnitId
+          if (focusedUnitId) {
+            if (event.detail >= 2) {
+              cancelPendingZonePaint(backgroundSelection.zoneId)
+              setSelection({ zoneId: backgroundSelection.zoneId })
+            } else {
+              paintZoneMembership(focusedUnitId, backgroundSelection.zoneId)
+            }
+            return
+          }
           setSelection({ zoneId: backgroundSelection.zoneId })
           return
         }

package/src/components/editor/handles/handle-placement.test.ts

@@ -0,0 +1,111 @@
+import { expect, test } from 'bun:test'
+import { type AnyNode, createSceneApi, type LinearResizeHandle, useScene } from '@pascal-app/core'
+import { Euler, Vector3 } from 'three'
+import { createArrowHandleGeometry } from './handle-arrow'
+import {
+  computeFreezeOffset,
+  resolveLinearHandlePosition,
+  resolveLinearHandleRotation,
+} from './handle-placement'
+
+const scene = createSceneApi(useScene)
+for (const axis of ['x', 'y', 'z'] as const) {
+  test(`${axis} clearance preserves sufficient offsets and keeps even hovered arrow tails clear at different scales`, () => {
+    const index = axis === 'x' ? 0 : axis === 'y' ? 1 : 2
+    const geometry = createArrowHandleGeometry(true)
+    geometry.computeBoundingBox()
+    const tail = geometry.boundingBox!.min.x * 1.12
+    for (const edge of [0.06, 1.2, -0.4]) {
+      const position: [number, number, number] = [0, 0, 0]
+      position[index] = edge + 0.15
+      const descriptor: LinearResizeHandle<null> = {
+        kind: 'linear-resize',
+        axis,
+        anchor: 'center',
+        currentValue: () => 1,
+        apply: () => null,
+        placement: { position: () => position, clearance: { edge: () => edge, distance: 0.4 } },
+      }
+      for (const scale of [0.1, 0.325, 0.65, 1.3, 3]) {
+        const resolved = resolveLinearHandlePosition(descriptor, null, scene, scale)
+        expect(resolved[index] + tail * scale - edge).toBeGreaterThan(0.1 * scale)
+        if (0.4 * scale <= 0.15) expect(resolved).toEqual(position)
+        resolved.forEach((value, i) => {
+          if (i !== index) expect(value).toBe(position[i]!)
+        })
+      }
+      delete descriptor.placement.clearance
+      expect(resolveLinearHandlePosition(descriptor, null, scene, 3)).toBe(position)
+    }
+    geometry.dispose()
+  })
+}
+
+test('array rotations keep sibling handles finite during rotation and resize', () => {
+  const initial = { position: [1, 2, 3], rotation: [0, Math.PI / 2, 0] } as unknown as AnyNode
+  const rotated = { ...initial, rotation: [0, Math.PI, 0] } as unknown as AnyNode
+  expect(computeFreezeOffset(rotated, initial)).toEqual([0, 0, 0])
+  const moved = { ...initial, position: [2, 4, 3] } as unknown as AnyNode
+  const offset = computeFreezeOffset(moved, initial)
+  expect(offset[0]).toBeCloseTo(0)
+  expect(offset[1]).toBe(2)
+  expect(offset[2]).toBeCloseTo(1)
+  expect(
+    computeFreezeOffset(moved, { ...initial, rotation: Math.PI / 2 } as unknown as AnyNode),
+  ).toEqual(offset)
+})
+
+for (const axis of ['x', 'y', 'z'] as const) {
+  test(`${axis} negative direction keeps hovered arrow above its lower-edge clearance`, () => {
+    const index = axis === 'x' ? 0 : axis === 'y' ? 1 : 2
+    const geometry = createArrowHandleGeometry(true)
+    geometry.computeBoundingBox()
+    const tail = -geometry.boundingBox!.min.x * 1.12
+    for (const edge of [-2, 0, 2]) {
+      const position: [number, number, number] = [0, 0, 0]
+      position[index] = edge - 0.15
+      const descriptor: LinearResizeHandle<null> = {
+        kind: 'linear-resize',
+        axis,
+        anchor: 'max',
+        direction: -1,
+        currentValue: () => 1,
+        apply: () => null,
+        placement: { position: () => position, clearance: { edge: () => edge, distance: 0.4 } },
+      }
+      for (const scale of [0.1, 0.325, 0.65, 1.3, 3]) {
+        const resolved = resolveLinearHandlePosition(descriptor, null, scene, scale)
+        expect(edge - (resolved[index] + tail * scale)).toBeGreaterThan(0.1 * scale)
+        if (0.4 * scale <= 0.15) expect(resolved).toEqual(position)
+        const pointing = new Vector3(1, 0, 0)
+          .applyEuler(new Euler(...resolveLinearHandleRotation(descriptor, resolved)))
+          .applyAxisAngle(new Vector3(0, 1, 0), axis === 'z' ? -Math.PI / 2 : 0)
+        expect(pointing.getComponent(index)).toBeCloseTo(-1)
+      }
+    }
+    geometry.dispose()
+  })
+}
+
+test('unspecified direction preserves vertical position heuristic and wall-facing blade', () => {
+  const descriptor: LinearResizeHandle<null> = {
+    kind: 'linear-resize',
+    axis: 'y',
+    anchor: 'min',
+    currentValue: () => 1,
+    apply: () => null,
+    placement: { position: () => [0, 0, 0] },
+  }
+  expect(resolveLinearHandleRotation(descriptor, [0, -1, 0])).toEqual([
+    0,
+    Math.PI / 2,
+    -Math.PI / 2,
+  ])
+  expect(resolveLinearHandleRotation(descriptor, [0, 1, 0])).toEqual([0, Math.PI / 2, Math.PI / 2])
+  expect(
+    resolveLinearHandleRotation({ ...descriptor, axis: 'x', faceNormal: true }, [0, 0, 0]),
+  ).toEqual([Math.PI / 2, 0, 0])
+  expect(
+    resolveLinearHandleRotation({ ...descriptor, axis: 'z', faceNormal: true }, [0, 0, 0]),
+  ).toEqual([0, 0, 0])
+})

package/src/components/editor/handles/handle-placement.ts

@@ -0,0 +1,69 @@
+import type { AnyNode, LinearResizeHandle, RadialResizeHandle, SceneApi } from '@pascal-app/core'
+
+export function resolveLinearHandlePosition<N>(
+  descriptor: LinearResizeHandle<N> | RadialResizeHandle<N>,
+  node: N,
+  scene: SceneApi,
+  baseScale: number,
+): readonly [number, number, number] {
+  const position = descriptor.placement.position(node, scene)
+  const clearance = descriptor.kind === 'linear-resize' ? descriptor.placement.clearance : undefined
+  if (!clearance) return position
+  const index = descriptor.axis === 'x' ? 0 : descriptor.axis === 'y' ? 1 : 2
+  const result: [number, number, number] = [...position]
+  const direction = descriptor.kind === 'linear-resize' ? (descriptor.direction ?? 1) : 1
+  const edge = clearance.edge(node, scene) + direction * clearance.distance * baseScale
+  result[index] = direction === -1 ? Math.min(result[index], edge) : Math.max(result[index], edge)
+  return result
+}
+
+export function resolveLinearHandleRotation<N>(
+  descriptor: LinearResizeHandle<N> | RadialResizeHandle<N>,
+  position: readonly [number, number, number],
+): [number, number, number] {
+  const direction = descriptor.kind === 'linear-resize' ? descriptor.direction : undefined
+  if (descriptor.axis === 'y') {
+    const sign = direction ?? (position[1] < 0 ? -1 : 1)
+    return [0, Math.PI / 2, (sign * Math.PI) / 2]
+  }
+  const faceNormal =
+    descriptor.kind === 'linear-resize' && descriptor.axis === 'x' && descriptor.faceNormal
+  return [faceNormal ? Math.PI / 2 : 0, 0, direction === -1 ? Math.PI : 0]
+}
+
+// Offset, in node-local frame, that compensates for `position` drift on
+// the mesh during an asymmetric resize. Width/length L+R recompute
+// `position` so the anchored edge stays world-fixed — the renderer
+// follows that override, the ride object moves, and every arrow under
+// it would drift along with the mesh center. Subtracting this offset
+// from a non-active arrow's local placement undoes that drift so it
+// stays at its pre-drag world position.
+//
+// Rotation drags don't change `position`, so the offset collapses to
+// zero and non-active arrows naturally rotate with the mesh — which is
+// the desired behaviour (the whole rig rotates as a unit).
+export function computeFreezeOffset(
+  liveNode: AnyNode,
+  preDragNode: AnyNode,
+): [number, number, number] {
+  // Not every node in the union carries a `position` field (sites are the
+  // notable holdout — they don't have handles anyway, but TypeScript still
+  // requires us to discriminate). Guarded access keeps the freeze logic
+  // safe for the few node kinds that lack the field.
+  const liveP = (liveNode as { position?: readonly [number, number, number] }).position ?? [0, 0, 0]
+  const preP = (preDragNode as { position?: readonly [number, number, number] }).position ?? [
+    0, 0, 0,
+  ]
+  const deltaWorldX = liveP[0] - preP[0]
+  const deltaWorldY = liveP[1] - preP[1]
+  const deltaWorldZ = liveP[2] - preP[2]
+  const rotation = (preDragNode as { rotation?: number | readonly number[] }).rotation
+  const rotY = typeof rotation === 'number' ? rotation : (rotation?.[1] ?? 0)
+  // World → node-local for Y-axis rotation by rotY (THREE.Object3D
+  // rotation-y convention): inverse is rotation by -rotY around +Y.
+  const cosR = Math.cos(rotY)
+  const sinR = Math.sin(rotY)
+  const deltaLocalX = cosR * deltaWorldX - sinR * deltaWorldZ
+  const deltaLocalZ = sinR * deltaWorldX + cosR * deltaWorldZ
+  return [deltaLocalX, deltaWorldY, deltaLocalZ]
+}

package/src/components/editor/handles/linear-resize-drag.ts

@@ -1,14 +1,23 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  cascadeDirty,
   type HandleDragModifiers,
   type LinearResizeHandle,
+  type RadialResizeHandle,
   type SceneApi,
   useLiveNodeOverrides,
   useScene,
 } from '@pascal-app/core'
 import { replacePreviewOverrideIds } from './preview-overrides'
 
+export function linearResizeFactor<N>(
+  descriptor: LinearResizeHandle<N> | RadialResizeHandle<N>,
+): number {
+  if (descriptor.kind === 'radial-resize') return 1
+  return descriptor.anchor === 'center' ? 2 : descriptor.anchor === 'min' ? 1 : -1
+}
+
 export function createLinearResizeDragBinding({
   descriptor,
   initialNode,
@@ -52,14 +61,16 @@ export function createLinearResizeDragBinding({
           previewEntries.map(([id, previewPatch]) => [id, previewPatch as Record<string, unknown>]),
         )
       for (const [previewId] of previewEntries) {
-        useScene.getState().markDirty(previewId)
+        for (const id of cascadeDirty(previewId, { scene: sceneApi }))
+          useScene.getState().markDirty(id)
       }
       return patch
     },
     clearPreview(): void {
       for (const previewId of previewOverrideIds) {
         useLiveNodeOverrides.getState().clear(previewId)
-        useScene.getState().markDirty(previewId)
+        for (const id of cascadeDirty(previewId, { scene: sceneApi }))
+          useScene.getState().markDirty(id)
       }
       previewOverrideIds = new Set()
     },

package/src/components/editor/handles/use-handle-drag.ts

@@ -4,6 +4,7 @@ import {
   type AnyNode,
   type AnyNodeId,
   type Cursor,
+  cascadeDirty,
   createSceneApi,
   type HandleDragModifiers,
   runAsSingleSceneHistoryStep,
@@ -198,7 +199,8 @@ export function useHandleDrag(args: UseHandleDragArgs) {
       lastPatch = patch
       useLiveNodeOverrides.getState().set(overrideId, patch as Record<string, unknown>)
       if (markDirty) {
-        useScene.getState().markDirty(overrideId)
+        for (const id of cascadeDirty(overrideId, { scene: createSceneApi(useScene) }))
+          useScene.getState().markDirty(id)
       }
     }
 
@@ -222,7 +224,8 @@ export function useHandleDrag(args: UseHandleDragArgs) {
     const clearOverride = () => {
       useLiveNodeOverrides.getState().clear(overrideId)
       if (markDirty) {
-        useScene.getState().markDirty(overrideId)
+        for (const id of cascadeDirty(overrideId, { scene: createSceneApi(useScene) }))
+          useScene.getState().markDirty(id)
       }
     }
 

package/src/components/editor/index.tsx

@@ -49,6 +49,7 @@ import {
   writePersistedSelection,
 } from '../../lib/scene'
 import { disposeSFXBus, initSFXBus } from '../../lib/sfx-bus'
+import { useUnitFocusRules } from '../../lib/units'
 import { type CameraHintAction, useCameraHintFocus } from '../../store/use-camera-hint-focus'
 import useEditor from '../../store/use-editor'
 import useFloorplanMode from '../../store/use-floorplan-mode'
@@ -1041,6 +1042,10 @@ const ViewerCanvas = memo(function ViewerCanvas({
   const setFloorplanPaneRatio = useEditor((s) => s.setFloorplanPaneRatio)
   const isPreviewMode = useEditor((s) => s.isPreviewMode)
   const isCaptureMode = useEditor((s) => s.isCaptureMode)
+  useUnitFocusRules()
+  const presetIsolation = useEditor((s) =>
+    s.captureMode.mode === 'preset' ? s.captureMode.isolated : null,
+  )
 
   const [isCameraControlsHintVisible, setIsCameraControlsHintVisible] = useState<boolean | null>(
     null,
@@ -1151,6 +1156,10 @@ const ViewerCanvas = memo(function ViewerCanvas({
             defaultRender={EDITOR_DEFAULT_RENDER}
             disablePostFx={disablePostFx}
             hoverStyles={EDITOR_HOVER_STYLES}
+            isolate={presetIsolation}
+            // Preset captures isolate one subtree and keep the exterior transparent.
+            // Other modes retain the viewer's configured background policy.
+            transparent={presetIsolation === null ? undefined : true}
             onSceneReadyChange={onSceneReadyChange}
             renderContext="editor"
             renderPaused={!show3d && !showLoader}
@@ -1347,10 +1356,9 @@ function EditorContent({
 
   // Load on mount, project switches, and explicit retry attempts.
   useEffect(() => {
-    void sceneLoadAttempt
     let cancelled = false
 
-    async function load() {
+    async function load(attempt: number) {
       isLoadingSceneRef.current = true
       setSceneLoadError(null)
       setHasLoadedInitialScene(false)
@@ -1364,7 +1372,7 @@ function EditorContent({
       let failed = false
       try {
         const sceneGraph = onLoad ? await onLoad() : loadSceneFromLocalStorage()
-        if (!cancelled) {
+        if (!cancelled && attempt === sceneLoadAttempt) {
           applySceneGraphToEditor(sceneGraph)
           setIsViewerSceneReady(false)
           setSceneReadyKey((key) => key + 1)
@@ -1390,7 +1398,7 @@ function EditorContent({
       }
     }
 
-    load()
+    load(sceneLoadAttempt)
 
     return () => {
       cancelled = true

package/src/components/editor/node-arrow-handles.tsx

@@ -47,6 +47,7 @@ import { createEditorApi } from '../../lib/editor-api'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import useDirectManipulationFeedback from '../../store/use-direct-manipulation-feedback'
 import useEditor, { isGridSnapActive, isMagneticSnapActive } from '../../store/use-editor'
+import { useHandleGroup } from '../../store/use-handle-group'
 import useInteractionScope, {
   useEndpointReshape,
   useIsCurveReshape,
@@ -62,7 +63,12 @@ import {
   HandleArrow,
   NO_RAYCAST,
 } from './handles/handle-arrow'
-import { createLinearResizeDragBinding } from './handles/linear-resize-drag'
+import {
+  computeFreezeOffset,
+  resolveLinearHandlePosition,
+  resolveLinearHandleRotation,
+} from './handles/handle-placement'
+import { createLinearResizeDragBinding, linearResizeFactor } from './handles/linear-resize-drag'
 import { resolveResizeSnapValue } from './handles/resize-snap'
 import { type HandleDragControls, useHandleDrag } from './handles/use-handle-drag'
 
@@ -227,6 +233,9 @@ export function NodeArrowHandles() {
     () => (rawNode && liveOverride ? ({ ...rawNode, ...liveOverride } as AnyNode) : rawNode),
     [rawNode, liveOverride],
   )
+  const activeGroup = useHandleGroup((s) =>
+    s.active && s.active.nodeId === node?.id ? s.active.group : null,
+  )
   const def = node ? nodeRegistry.get(node.type) : null
   const descriptorSceneApi = useMemo(() => createSceneApi(useScene), [])
   const descriptors = useMemo(() => {
@@ -236,6 +245,8 @@ export function NodeArrowHandles() {
         ? def.handles(node as never, descriptorSceneApi)
         : (def.handles as HandleDescriptor[])
     return all.filter((descriptor) => {
+      if (activeGroup)
+        return descriptor.kind === 'linear-resize' && descriptor.latchGroup === activeGroup
       if (descriptor.kind === 'translate') return false
       const visible =
         'visible' in descriptor
@@ -244,7 +255,7 @@ export function NodeArrowHandles() {
       if ('shape' in descriptor && descriptor.shape === 'move-cross') return visible === true
       return visible !== false
     })
-  }, [node, def, descriptorSceneApi])
+  }, [node, def, descriptorSceneApi, activeGroup])
 
   const shouldRender =
     Boolean(node && descriptors?.length) &&
@@ -291,6 +302,9 @@ function NodeArrowHandlesForNode({
   node: AnyNode
   descriptors: HandleDescriptor[]
 }) {
+  const controlledGroup = useHandleGroup((s) =>
+    s.active?.nodeId === node.id ? s.active.group : null,
+  )
   const parentId = node.parentId ?? null
 
   const portalMode: HandlePortal = descriptors.some((d) => d.portal === 'grandparent')
@@ -476,7 +490,8 @@ function NodeArrowHandlesForNode({
     }
     // Arrows tagged with a latch group stay hidden until that group is open.
     const latchGroup = descriptor.kind === 'linear-resize' ? descriptor.latchGroup : undefined
-    if (latchGroup && !openLatchGroups.has(latchGroup)) return null
+    if (latchGroup && latchGroup !== controlledGroup && !openLatchGroups.has(latchGroup))
+      return null
     return (
       <ArrowHandle
         activeIndex={activeIndex}
@@ -502,39 +517,6 @@ function NodeArrowHandlesForNode({
   )
 }
 
-// Offset, in node-local frame, that compensates for `position` drift on
-// the mesh during an asymmetric resize. Width/length L+R recompute
-// `position` so the anchored edge stays world-fixed — the renderer
-// follows that override, the ride object moves, and every arrow under
-// it would drift along with the mesh center. Subtracting this offset
-// from a non-active arrow's local placement undoes that drift so it
-// stays at its pre-drag world position.
-//
-// Rotation drags don't change `position`, so the offset collapses to
-// zero and non-active arrows naturally rotate with the mesh — which is
-// the desired behaviour (the whole rig rotates as a unit).
-function computeFreezeOffset(liveNode: AnyNode, preDragNode: AnyNode): [number, number, number] {
-  // Not every node in the union carries a `position` field (sites are the
-  // notable holdout — they don't have handles anyway, but TypeScript still
-  // requires us to discriminate). Guarded access keeps the freeze logic
-  // safe for the few node kinds that lack the field.
-  const liveP = (liveNode as { position?: readonly [number, number, number] }).position ?? [0, 0, 0]
-  const preP = (preDragNode as { position?: readonly [number, number, number] }).position ?? [
-    0, 0, 0,
-  ]
-  const deltaWorldX = liveP[0] - preP[0]
-  const deltaWorldY = liveP[1] - preP[1]
-  const deltaWorldZ = liveP[2] - preP[2]
-  const rotY = (preDragNode as { rotation?: number }).rotation ?? 0
-  // World → node-local for Y-axis rotation by rotY (THREE.Object3D
-  // rotation-y convention): inverse is rotation by -rotY around +Y.
-  const cosR = Math.cos(rotY)
-  const sinR = Math.sin(rotY)
-  const deltaLocalX = cosR * deltaWorldX - sinR * deltaWorldZ
-  const deltaLocalZ = sinR * deltaWorldX + cosR * deltaWorldZ
-  return [deltaLocalX, deltaWorldY, deltaLocalZ]
-}
-
 function ArrowHandle({
   descriptor,
   liveNode,
@@ -666,7 +648,7 @@ function LinearArrow({
   // for the edge being resized); cleared when the drag ends.
   const onDrag = descriptor.kind === 'linear-resize' ? descriptor.onDrag : undefined
   const placementSceneApi = useMemo(() => createSceneApi(useScene), [])
-  const basePosition = descriptor.placement.position(node, placementSceneApi)
+  const basePosition = resolveLinearHandlePosition(descriptor, node, placementSceneApi, baseScale)
   // `freezeOffset` (in node-local frame) cancels the mesh's `position`
   // drift while another arrow is being dragged — `basePosition` is
   // computed against the pre-drag snapshot, then we subtract the offset
@@ -730,14 +712,7 @@ function LinearArrow({
       const initialValue = descriptor.currentValue(initialNode)
       const minBound = resolveBound(descriptor.min, Number.NEGATIVE_INFINITY, initialNode, sceneApi)
       const maxBound = resolveBound(descriptor.max, Number.POSITIVE_INFINITY, initialNode, sceneApi)
-      const factor =
-        descriptor.kind === 'radial-resize'
-          ? 1
-          : descriptor.anchor === 'center'
-            ? 2
-            : descriptor.anchor === 'min'
-              ? 1
-              : -1
+      const factor = linearResizeFactor(descriptor)
 
       // Last value an emitted resize tick fired at — a new tick fires only
       // when the (snapped + clamped) value actually changes, so the cue
@@ -806,23 +781,7 @@ function LinearArrow({
     },
   })
 
-  // For axis === 'y' (vertical handles), tilt the chevron up via local
-  // X+Z rotation chain matching DoorHeightArrowHandle. When the handle
-  // sits below the node (placement Y < 0, e.g. window bottom arrow),
-  // flip the Z rotation so the chevron points outward (downward).
-  //
-  // For axis === 'x' with `faceNormal` (wall-mounted opening width arrows),
-  // roll the blade 90° about its own pointing (X) axis so it stands up from
-  // the horizontal XZ plane into the node's facing plane (XY = the wall
-  // face) — otherwise the blade is seen edge-on from the front.
-  const faceNormalX =
-    descriptor.kind === 'linear-resize' && descriptor.axis === 'x' && descriptor.faceNormal === true
-  const innerRotation: [number, number, number] =
-    descriptor.axis === 'y'
-      ? [0, Math.PI / 2, position[1] < 0 ? -Math.PI / 2 : Math.PI / 2]
-      : faceNormalX
-        ? [Math.PI / 2, 0, 0]
-        : [0, 0, 0]
+  const innerRotation = resolveLinearHandleRotation(descriptor, position)
 
   // Optional guide decoration — linear handles use it for curved-stair
   // width / inner-radius rings; radial handles use it for the column's