@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/continuation.ts

@@ -0,0 +1,64 @@
+export type ContinuationContext = 'wall' | 'fence' | 'point' | 'cabinet'
+export type ContinuationMode = string
+
+export const CONTINUATION_PROFILES: Record<
+  ContinuationContext,
+  {
+    options: ContinuationMode[]
+    default: ContinuationMode
+    labels: Record<string, string>
+    icons: Record<string, string>
+  }
+> = {
+  wall: {
+    options: ['room', 'single'],
+    default: 'room',
+    labels: { room: 'Room (auto-close)', single: 'Single wall' },
+    icons: { room: 'lucide:square', single: 'lucide:minus' },
+  },
+  fence: {
+    options: ['single', 'continuous', 'curved'],
+    default: 'continuous',
+    labels: {
+      continuous: 'Continuous',
+      single: 'Single fence',
+      curved: 'Curved fence',
+    },
+    icons: {
+      continuous: 'lucide:waypoints',
+      single: 'lucide:minus',
+      curved: 'lucide:spline',
+    },
+  },
+  point: {
+    options: ['once', 'repeat'],
+    default: 'once',
+    labels: { once: 'Place once', repeat: 'Place multiple' },
+    icons: { once: 'lucide:target', repeat: 'lucide:copy-plus' },
+  },
+  cabinet: {
+    options: ['single', 'continuous'],
+    default: 'single',
+    labels: { single: 'Single cabinet', continuous: 'Continuous run' },
+    icons: { single: 'lucide:minus', continuous: 'lucide:waypoints' },
+  },
+}
+
+const POINT_KINDS = new Set(['item', 'door', 'window', 'shelf', 'column'])
+
+export function nextContinuation(
+  context: ContinuationContext,
+  current: ContinuationMode,
+): ContinuationMode {
+  const profile = CONTINUATION_PROFILES[context]
+  const index = profile.options.indexOf(current)
+  if (index === -1) return profile.default
+  return profile.options[(index + 1) % profile.options.length] ?? profile.default
+}
+
+export function continuationContextOf(kind: string): ContinuationContext | null {
+  if (kind === 'wall') return 'wall'
+  if (kind === 'fence') return 'fence'
+  if (kind === 'cabinet') return 'cabinet'
+  return POINT_KINDS.has(kind) ? 'point' : null
+}

package/src/lib/direct-manipulation.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  DEFAULT_ANGLE_STEP,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  canDirectMoveNode,
+  resolveDirectManipulationNode,
+  resolveDirectRotationDragDelta,
+  snapDirectRotationDelta,
+} from './direct-manipulation'
+
+function registerTestDefinition(kind: string, overrides: Partial<AnyNodeDefinition>) {
+  if (nodeRegistry.has(kind)) return
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(kind) }) as never,
+    category: 'structure',
+    defaults: () => ({ type: kind }) as never,
+    capabilities: {},
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    ...overrides,
+  } as AnyNodeDefinition)
+}
+
+describe('snapDirectRotationDelta', () => {
+  test('snaps rotation deltas to the default angle increment', () => {
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * 0.49, false)).toBe(0)
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * 0.51, false)).toBeCloseTo(
+      DEFAULT_ANGLE_STEP,
+    )
+    expect(snapDirectRotationDelta(DEFAULT_ANGLE_STEP * -1.49, false)).toBeCloseTo(
+      -DEFAULT_ANGLE_STEP,
+    )
+  })
+
+  test('keeps the raw rotation delta while free-rotating', () => {
+    const rawDelta = DEFAULT_ANGLE_STEP * 0.42
+    expect(snapDirectRotationDelta(rawDelta, true)).toBe(rawDelta)
+  })
+})
+
+describe('resolveDirectRotationDragDelta', () => {
+  test('maps horizontal pointer motion to the direct rotation delta direction', () => {
+    const radiansPerPixel = DEFAULT_ANGLE_STEP / 12
+
+    expect(resolveDirectRotationDragDelta(100, 112, radiansPerPixel, false)).toBeCloseTo(
+      -DEFAULT_ANGLE_STEP,
+    )
+    expect(resolveDirectRotationDragDelta(100, 88, radiansPerPixel, false)).toBeCloseTo(
+      DEFAULT_ANGLE_STEP,
+    )
+  })
+
+  test('keeps unsnapped drag deltas while free-rotating', () => {
+    expect(resolveDirectRotationDragDelta(100, 103, 0.1, true)).toBeCloseTo(-0.3)
+  })
+})
+
+describe('canDirectMoveNode', () => {
+  // Accepts kinds with a 3D-mountable move tool (`movable` or
+  // `affordanceTools.move`); floorplan-only movers (zone) are excluded.
+  test('rejects floorplan-only move targets (no 3D tool mounts)', () => {
+    const kind = 'direct-move-floorplan-only-test'
+    registerTestDefinition(kind, { floorplanMoveTarget: {} as never })
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+  })
+
+  test('rejects MEP kinds that own move through bespoke selection affordances', () => {
+    for (const kind of [
+      'duct-segment',
+      'duct-fitting',
+      'pipe-segment',
+      'pipe-fitting',
+      'lineset',
+      'liquid-line',
+    ]) {
+      expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+    }
+  })
+
+  test('accepts kinds with a bespoke move tool', () => {
+    const kind = 'direct-move-bespoke-tool-test'
+    registerTestDefinition(kind, {
+      affordanceTools: {
+        move: async () => ({ default: () => null }),
+      } as never,
+    })
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(true)
+  })
+
+  test('accepts nodes with the generic movable capability', () => {
+    const kind = 'direct-move-movable-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: { axes: ['x', 'z'], gridSnap: true },
+      },
+    } as Partial<AnyNodeDefinition>)
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(true)
+  })
+
+  test('rejects kinds with no registered move path', () => {
+    const kind = 'direct-move-none-test'
+    registerTestDefinition(kind, {})
+
+    expect(canDirectMoveNode({ id: 'node_1', type: kind } as unknown as AnyNode)).toBe(false)
+  })
+})
+
+describe('resolveDirectManipulationNode', () => {
+  test('routes proxied members to their assembly for direct transforms', () => {
+    const group = {
+      id: 'direct_manipulation_group',
+      type: 'direct-manipulation-group-test',
+    } as unknown as AnyNode
+    const member = {
+      id: 'direct_manipulation_member',
+      type: 'direct-manipulation-member-test',
+      metadata: { nodeSelectionProxyId: group.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveDirectManipulationNode(member, {
+        [group.id]: group,
+        [member.id]: member,
+      }),
+    ).toBe(group)
+  })
+
+  test('falls back to the selected node when the proxy target is missing', () => {
+    const member = {
+      id: 'direct_manipulation_orphan_member',
+      type: 'direct-manipulation-member-test',
+      metadata: { nodeSelectionProxyId: 'missing_group' },
+    } as unknown as AnyNode
+
+    expect(resolveDirectManipulationNode(member, { [member.id]: member })).toBe(member)
+  })
+
+  test('routes parent-frame children to their rotatable parent', () => {
+    const parentKind = 'direct-manipulation-parent-frame-parent-test'
+    const childKind = 'direct-manipulation-parent-frame-child-test'
+    registerTestDefinition(parentKind, {
+      capabilities: { rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] } },
+    })
+    registerTestDefinition(childKind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+            parentRotationY: () => 0,
+            localToPlan: (_parent: AnyNode, local: readonly [number, number, number]) => [
+              local[0],
+              local[1],
+              local[2],
+            ],
+            planToLocal: (_parent: AnyNode, planX: number, localY: number, planZ: number) => [
+              planX,
+              localY,
+              planZ,
+            ],
+          },
+        },
+      },
+    })
+
+    const parent = { id: 'direct_manipulation_parent', type: parentKind } as unknown as AnyNode
+    const child = {
+      id: 'direct_manipulation_child',
+      type: childKind,
+      parentId: parent.id,
+    } as unknown as AnyNode
+
+    expect(
+      resolveDirectManipulationNode(child, {
+        [parent.id]: parent,
+        [child.id]: child,
+      }),
+    ).toBe(parent)
+  })
+})

package/src/lib/direct-manipulation.ts

@@ -0,0 +1,109 @@
+import {
+  type AnyNode,
+  type ArcResizeHandle,
+  createSceneApi,
+  DEFAULT_ANGLE_STEP,
+  type HandleDescriptor,
+  hasRegistry3DMoveTool,
+  isMovable,
+  nodeRegistry,
+  resolveSelectionProxyId,
+  type SceneApi,
+  useScene,
+} from '@pascal-app/core'
+
+function resolveHandles(node: AnyNode): HandleDescriptor<AnyNode>[] {
+  const handles = nodeRegistry.get(node.type)?.handles
+  if (!handles) return []
+  return (
+    typeof handles === 'function' ? handles(node as never) : handles
+  ) as HandleDescriptor<AnyNode>[]
+}
+
+export function getDirectRotateHandle(node: AnyNode): ArcResizeHandle<AnyNode> | null {
+  for (const handle of resolveHandles(node)) {
+    if (handle.kind === 'arc-resize' && handle.shape === 'rotate') {
+      return handle as ArcResizeHandle<AnyNode>
+    }
+  }
+  return null
+}
+
+export function canDirectRotateNode(node: AnyNode): boolean {
+  return (
+    getDirectRotateHandle(node) !== null ||
+    nodeRegistry.get(node.type)?.capabilities?.rotatable !== undefined
+  )
+}
+
+const BESPOKE_SELECTION_MOVE_KINDS = new Set([
+  'duct-segment',
+  'duct-fitting',
+  'pipe-segment',
+  'pipe-fitting',
+  'lineset',
+  'liquid-line',
+])
+
+export function canDirectMoveNode(node: AnyNode): boolean {
+  // These MEP kinds own move through bespoke selection rigs (latch cubes,
+  // directional arrows, grid-driven previews). Sending body drags/clicks
+  // through the generic direct-move handoff conflicts with that path and can
+  // leave the editor appearing frozen while their mover waits for the wrong
+  // gesture stream.
+  if (BESPOKE_SELECTION_MOVE_KINDS.has(node.type)) return false
+  // 3D direct move (Ctrl/Meta-drag, the move-cross grip) needs a move tool that
+  // mounts in 3D — distinct from `isRegistryMovable`, which also accepts
+  // floorplan-only movers (zone) for the 2D plan.
+  if (!hasRegistry3DMoveTool(node.type)) return false
+  // Bespoke movers (`affordanceTools.move`) own their constraints and often
+  // deliberately omit `capabilities.movable` — only gate registry-movable
+  // kinds on `isMovable`, so a per-node `movable.override` (e.g. a cabinet
+  // run locked behind its selection proxy) can opt out of direct move.
+  if (nodeRegistry.get(node.type)?.affordanceTools?.move) return true
+  return isMovable(node)
+}
+
+export function resolveDirectManipulationNode(
+  node: AnyNode,
+  nodes: Readonly<Record<string, AnyNode | undefined>>,
+): AnyNode {
+  const target = nodes[resolveSelectionProxyId(node, nodes)] ?? node
+  const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
+  const parent = parentFrame?.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
+  return parent && canDirectRotateNode(parent) ? parent : target
+}
+
+export function snapDirectRotationDelta(delta: number, free: boolean): number {
+  return free ? delta : Math.round(delta / DEFAULT_ANGLE_STEP) * DEFAULT_ANGLE_STEP
+}
+
+export function resolveDirectRotationDragDelta(
+  startX: number,
+  clientX: number,
+  radiansPerPixel: number,
+  free: boolean,
+): number {
+  return snapDirectRotationDelta((startX - clientX) * radiansPerPixel, free)
+}
+
+export function resolveDirectRotationPatch(
+  node: AnyNode,
+  delta: number,
+  sceneApi: SceneApi = createSceneApi(useScene),
+): Partial<AnyNode> | null {
+  const rotateHandle = getDirectRotateHandle(node)
+  if (rotateHandle) {
+    return rotateHandle.apply(node, delta, sceneApi) as Partial<AnyNode>
+  }
+
+  const rotation = (node as { rotation?: unknown }).rotation
+  if (typeof rotation === 'number') {
+    return { rotation: rotation - delta } as Partial<AnyNode>
+  }
+  if (Array.isArray(rotation)) {
+    const [rx = 0, ry = 0, rz = 0] = rotation as [number?, number?, number?]
+    return { rotation: [rx, ry - delta, rz] } as Partial<AnyNode>
+  }
+  return null
+}

package/src/lib/editor-api.ts

@@ -1,33 +1,20 @@
-import type { AnyNode, EditorApi, FenceNode, WallNode } from '@pascal-app/core'
+import type { AnyNode, EditorApi } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
-
-type EditorState = ReturnType<typeof useEditor.getState>
-type EndpointEngager = (node: AnyNode, endpoint: 'start' | 'end', editor: EditorState) => void
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  controlPointReshapeScope,
+  endpointReshapeScope,
+  tangentReshapeScope,
+} from './interaction/scope'
 
 /**
- * Per-kind endpoint-move engagement. Kinds whose 2D endpoint drag
- * needs its own store field (wall ↔ `movingWallEndpoint`, fence ↔
- * `movingFenceEndpoint`) register their bridge here. The dispatcher
- * is a table lookup rather than an `if (type === 'wall')` chain so
- * adding a new endpoint-draggable kind is a one-line entry instead
- * of a new branch. Each entry casts the generic `AnyNode` to its
- * concrete kind — the lookup key already guarantees the type.
- */
-const endpointEngagers: Record<string, EndpointEngager> = {
-  wall: (node, endpoint, editor) =>
-    editor.setMovingWallEndpoint({ wall: node as WallNode, endpoint }),
-  fence: (node, endpoint, editor) =>
-    editor.setMovingFenceEndpoint({ fence: node as FenceNode, endpoint }),
-}
-
-/**
- * Concrete {@link EditorApi} backed by `useEditor`. Descriptors call into
- * editor state through this interface; the editor owns the actual setter
- * names so core stays decoupled.
+ * Concrete {@link EditorApi} backed by `useEditor` + the interaction scope.
+ * Descriptors call into editor state through this interface; the editor owns
+ * the actual store wiring so core stays decoupled.
  *
- * `engageMove` clears any in-progress endpoint drag or curve gesture so
- * the move tool takes over cleanly — mirrors the legacy bookkeeping that
- * lived inside `WallMoveArrowHandle.activateWallMove` / `FenceMoveArrowHandle`.
+ * `engageMove` no longer clears any in-progress endpoint drag or curve gesture:
+ * `setMovingNode` begins the `moving` scope, and the scope is single-owner, so
+ * it atomically replaces any prior reshape — there is no separate flag to reset.
  */
 export function createEditorApi(): EditorApi {
   return {
@@ -39,10 +26,6 @@ export function createEditorApi(): EditorApi {
       // cast lets registry-driven move kinds through without forcing a
       // schema-level type widening.
       editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
-      editor.setMovingWallEndpoint(null)
-      editor.setMovingFenceEndpoint(null)
-      editor.setCurvingWall(null)
-      editor.setCurvingFence(null)
     },
     engageMoveDrag(node: AnyNode) {
       const editor = useEditor.getState()
@@ -50,13 +33,18 @@ export function createEditorApi(): EditorApi {
       // it at setup and wires its commit-on-release listener.
       editor.setPlacementDragMode(true)
       editor.setMovingNode(node as Parameters<typeof editor.setMovingNode>[0])
-      editor.setMovingWallEndpoint(null)
-      editor.setMovingFenceEndpoint(null)
-      editor.setCurvingWall(null)
-      editor.setCurvingFence(null)
     },
     engageEndpointMove(node: AnyNode, endpoint: 'start' | 'end') {
-      endpointEngagers[node.type]?.(node, endpoint, useEditor.getState())
+      // Endpoint reshape is kind-agnostic: the scope carries the node id + which
+      // endpoint, and consumers recover the node from the scene. Adding a new
+      // endpoint-draggable kind needs no entry here.
+      useInteractionScope.getState().begin(endpointReshapeScope(node.id, endpoint))
+    },
+    engageControlPointMove(node: AnyNode, index: number) {
+      useInteractionScope.getState().begin(controlPointReshapeScope(node.id, index))
+    },
+    engageTangentMove(node: AnyNode, index: number, side: 'in' | 'out') {
+      useInteractionScope.getState().begin(tangentReshapeScope(node.id, index, side))
     },
   }
 }

package/src/lib/floorplan/apply-alignment.test.ts

@@ -0,0 +1,25 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import useAlignmentGuides from '../../store/use-alignment-guides'
+import { applyFloorplanAlignment } from './apply-alignment'
+
+describe('applyFloorplanAlignment', () => {
+  afterEach(() => {
+    useAlignmentGuides.getState().clear()
+  })
+
+  test('can publish passive guides without applying snap', () => {
+    useAlignmentGuides.getState().clear()
+
+    const result = applyFloorplanAlignment(
+      [0.04, 2],
+      [{ nodeId: 'draft', kind: 'corner', x: 0.04, z: 2 }],
+      [{ nodeId: 'wall_a', kind: 'corner', x: 0, z: 0 }],
+      { applySnap: false },
+    )
+
+    expect(result.point).toEqual([0.04, 2])
+    expect(result.snapped).toBe(false)
+    expect(result.guides).toHaveLength(1)
+    expect(useAlignmentGuides.getState().guides).toHaveLength(1)
+  })
+})

package/src/lib/floorplan/apply-alignment.ts

@@ -2,10 +2,10 @@ import {
   type AlignmentAnchor,
   type AlignmentGuide,
   collectAlignmentAnchors,
-  resolveAlignment,
   useScene,
 } from '@pascal-app/core'
-import { useAlignmentGuides } from '@pascal-app/editor'
+import useAlignmentGuides from '../../store/use-alignment-guides'
+import { resolveAlignmentForFloorplanView } from '../world-grid-snap'
 
 /**
  * Fixed Figma-style alignment threshold (meters) for floor-plan placement /
@@ -30,9 +30,9 @@ export type FloorplanAlignmentResult = {
  *
  * Publishes guides to the `useAlignmentGuides` store as a side effect — set
  * on a match, cleared otherwise — so the mounted `FloorplanAlignmentGuideLayer`
- * renders them. Returns the adjusted point. When `bypass` is true (Alt held)
- * the point is returned unchanged and guides are cleared, matching the
- * "No snap" affordance the placement tools advertise.
+ * renders them. Returns the adjusted point. When `bypass` is true (Alt for
+ * alignment-only bypass, or Shift for the full guided-constraint bypass) the
+ * point is returned unchanged and guides are cleared.
  *
  * `candidates` should be gathered ONCE per drag (`collectAlignmentAnchors`);
  * the scene is stable during a single drag, so re-collecting per pointer-move
@@ -42,14 +42,14 @@ export function applyFloorplanAlignment(
   point: readonly [number, number],
   movingAnchors: AlignmentAnchor[],
   candidates: AlignmentAnchor[],
-  opts?: { bypass?: boolean; threshold?: number },
+  opts?: { applySnap?: boolean; bypass?: boolean; threshold?: number },
 ): FloorplanAlignmentResult {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
     return { point: [point[0], point[1]], snapped: false, guides: [] }
   }
 
-  const result = resolveAlignment({
+  const result = resolveAlignmentForFloorplanView({
     moving: movingAnchors,
     candidates,
     threshold: opts?.threshold ?? FLOORPLAN_ALIGNMENT_THRESHOLD_M,
@@ -57,7 +57,7 @@ export function applyFloorplanAlignment(
 
   useAlignmentGuides.getState().set(result.guides)
 
-  if (!result.snap) {
+  if (!result.snap || opts?.applySnap === false) {
     return { point: [point[0], point[1]], snapped: false, guides: result.guides }
   }
   return {
@@ -81,8 +81,9 @@ export const FLOORPLAN_DRAFT_ALIGN_ID = '__floorplan_draft__'
  *
  * Used by BOTH the move-preview branch and the click-commit handler so the
  * committed vertex lands exactly where the preview showed it. Caller owns the
- * per-kind precedence (existing-wall endpoint/join snap wins; angle-snap
- * suppresses alignment) and only calls this when alignment should apply.
+ * per-kind precedence: existing-wall endpoint/join snap can still win, while
+ * angle-locked segments can pass `applySnap: false` to publish passive guide
+ * feedback without pulling the endpoint off its constrained ray.
  *
  * `excludeIds` drops those nodes' anchors from the candidate pool — used when
  * dragging a wall / fence endpoint so the moving endpoint doesn't try to
@@ -90,7 +91,12 @@ export const FLOORPLAN_DRAFT_ALIGN_ID = '__floorplan_draft__'
  */
 export function alignFloorplanDraftPoint(
   point: readonly [number, number],
-  opts?: { bypass?: boolean; threshold?: number; excludeIds?: readonly string[] },
+  opts?: {
+    applySnap?: boolean
+    bypass?: boolean
+    threshold?: number
+    excludeIds?: readonly string[]
+  },
 ): [number, number] {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
@@ -105,7 +111,7 @@ export function alignFloorplanDraftPoint(
     point,
     [{ nodeId: FLOORPLAN_DRAFT_ALIGN_ID, kind: 'corner', x: point[0], z: point[1] }],
     candidates,
-    { threshold: opts?.threshold },
+    { applySnap: opts?.applySnap, threshold: opts?.threshold },
   )
   return snapped
 }