@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/scene-clipboard.ts

@@ -3,6 +3,7 @@ import {
   type AnyNodeId,
   generateId,
   type LevelNode,
+  remapMeasurementReferences,
   type StairNode,
   useScene,
 } from '@pascal-app/core'
@@ -30,6 +31,9 @@ const COPYABLE_ROOT_TYPES = new Set<AnyNode['type']>([
   'stair',
   'spawn',
   'zone',
+  'cabinet',
+  'cabinet-module',
+  'measurement',
 ])
 
 let clipboardPayload: ClipboardPayload | null = null
@@ -99,6 +103,30 @@ function isLevelChildRoot(nodes: Record<AnyNodeId, AnyNode>, node: AnyNode) {
   return nodes[parentId]?.type === 'level'
 }
 
+function getPromotedCabinetRunId(
+  nodes: Record<AnyNodeId, AnyNode>,
+  node: AnyNode,
+  selectedIds: Set<AnyNodeId>,
+) {
+  if (node.type !== 'cabinet-module') return null
+
+  const parentId = node.parentId as AnyNodeId | null
+  const parent = parentId ? nodes[parentId] : null
+  if (parent?.type !== 'cabinet') return null
+  if (!parentId) return null
+  if (selectedIds.has(parentId)) return parentId
+
+  const siblingIds = Array.isArray(parent.children) ? (parent.children as AnyNodeId[]) : []
+  const hasOnlySelectedModules =
+    siblingIds.length > 0 &&
+    siblingIds.every((childId) => {
+      const child = nodes[childId]
+      return child?.type === 'cabinet-module' && selectedIds.has(childId)
+    })
+
+  return hasOnlySelectedModules ? parentId : null
+}
+
 function getPasteTargetLevel(targetLevelId?: AnyNodeId) {
   const scene = useScene.getState()
   const resolvedLevelId =
@@ -114,7 +142,7 @@ function getNextLevelId(level: LevelNode, nodes: Record<AnyNodeId, AnyNode>) {
   if (!parentId) return null
 
   const building = nodes[parentId]
-  if (!building || building.type !== 'building') return null
+  if (building?.type !== 'building') return null
 
   const siblingLevels = building.children
     .map((childId) => nodes[childId as AnyNodeId])
@@ -165,6 +193,10 @@ function remapNodeReferences(
     ;(clone as StairNode).toLevelId = nextLevelId
   }
 
+  if (clone.type === 'measurement') {
+    clone.measurement = remapMeasurementReferences(clone.measurement, idMap)
+  }
+
   const metadata =
     clone.metadata && typeof clone.metadata === 'object' && !Array.isArray(clone.metadata)
       ? { ...(clone.metadata as Record<string, unknown>) }
@@ -176,11 +208,14 @@ function remapNodeReferences(
   return AnyNode.parse(clone)
 }
 
-export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
+function buildClipboardPayload(ids: AnyNodeId[]): ClipboardPayload | null {
   const scene = useScene.getState()
-  const ids = selectedIds ?? (useViewer.getState().selection.selectedIds as AnyNodeId[])
   const selectedIdSet = new Set(ids)
-  const rootIds = ids.filter((id) => {
+  const promotedIds = ids.map((id) => {
+    const node = scene.nodes[id]
+    return node ? (getPromotedCabinetRunId(scene.nodes, node, selectedIdSet) ?? id) : id
+  })
+  const rootIds = Array.from(new Set(promotedIds)).filter((id) => {
     const node = scene.nodes[id]
     return (
       node &&
@@ -191,7 +226,7 @@ export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
   })
 
   if (rootIds.length === 0) {
-    return false
+    return null
   }
 
   const subtreeIds = new Set<AnyNodeId>()
@@ -199,7 +234,7 @@ export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
     collectSubtreeIds(scene.nodes, rootId, subtreeIds)
   }
 
-  clipboardPayload = {
+  return {
     copiedAt: Date.now(),
     nodes: [...subtreeIds]
       .map((id) => scene.nodes[id])
@@ -207,15 +242,45 @@ export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
       .map((node) => JSON.parse(JSON.stringify(node)) as AnyNode),
     rootIds,
   }
+}
+
+export function copySelectedNodesToEditorClipboard(selectedIds?: AnyNodeId[]) {
+  const ids = selectedIds ?? (useViewer.getState().selection.selectedIds as AnyNodeId[])
+  const payload = buildClipboardPayload(ids)
+  if (!payload) return false
+
+  clipboardPayload = payload
   notifySubscribers()
 
   return true
 }
 
+/**
+ * Clone the given nodes (subtrees included, ids remapped) onto the target /
+ * active level in place — the same copy + paste pipeline in one step, WITHOUT
+ * touching the user's editor clipboard. Selects the clones. Used by the group
+ * action menu's Duplicate.
+ */
+export function duplicateNodesToLevel(
+  ids: AnyNodeId[],
+  targetLevelId?: AnyNodeId,
+): PasteResult | null {
+  const payload = buildClipboardPayload(ids)
+  if (!payload) return null
+  return applyClipboardPayloadToLevel(payload, targetLevelId)
+}
+
 export function pasteEditorClipboardToLevel(targetLevelId?: AnyNodeId): PasteResult | null {
-  const payload = clipboardPayload
+  if (!clipboardPayload) return null
+  return applyClipboardPayloadToLevel(clipboardPayload, targetLevelId)
+}
+
+function applyClipboardPayloadToLevel(
+  payload: ClipboardPayload,
+  targetLevelId?: AnyNodeId,
+): PasteResult | null {
   const targetLevel = getPasteTargetLevel(targetLevelId)
-  if (!payload || !targetLevel) return null
+  if (!targetLevel) return null
 
   const scene = useScene.getState()
   const idMap = new Map<AnyNodeId, AnyNodeId>()

package/src/lib/scene.ts

@@ -1,16 +1,28 @@
 'use client'
 
-import { nodeRegistry, resolveLevelId, sceneRegistry, useScene } from '@pascal-app/core'
+import {
+  clearSceneHistory,
+  nodeRegistry,
+  resolveLevelId,
+  sceneRegistry,
+  useScene,
+} from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import useEditor, {
   hasCustomPersistedEditorUiState,
   normalizePersistedEditorUiState,
   type PersistedEditorUiState,
 } from '../store/use-editor'
+import { editorHostPanelRegistry } from './plugin-panels'
 
 export type SceneGraph = {
   nodes: Record<string, unknown>
   rootNodeIds: string[]
+  // Document-level scene state that travels with the graph. Optional so older
+  // payloads (and callers that only build nodes) stay valid.
+  collections?: Record<string, unknown>
+  materials?: Record<string, unknown>
+  installedPlugins?: string[]
 }
 
 type PersistedSelectionPath = {
@@ -355,10 +367,8 @@ function resetEditorInteractionState() {
     structureLayer: 'elements',
     catalogCategory: null,
     selectedItem: null,
-    movingNode: null,
     selectedReferenceId: null,
     spaces: {},
-    editingHole: null,
     hoveredHole: null,
     isPreviewMode: false,
   })
@@ -373,13 +383,26 @@ function hasUsableSceneGraph(sceneGraph?: SceneGraph | null): sceneGraph is Scen
 }
 
 export function applySceneGraphToEditor(sceneGraph?: SceneGraph | null) {
+  const defaultInstalledPlugins = editorHostPanelRegistry.getDefaultInstalledPluginIds()
   if (hasUsableSceneGraph(sceneGraph)) {
-    const { nodes, rootNodeIds } = sceneGraph
-    useScene.getState().setScene(nodes as any, rootNodeIds as any)
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph
+    useScene.getState().setScene(nodes as any, rootNodeIds as any, {
+      collections: collections as any,
+      materials: materials as any,
+      installedPlugins: installedPlugins ?? defaultInstalledPlugins,
+      hasExplicitPluginInstallState: installedPlugins !== undefined,
+    })
   } else {
     useScene.getState().clearScene()
+    useScene.getState().setInstalledPlugins(defaultInstalledPlugins, { explicit: false })
   }
 
+  // The loaded scene is the undo floor. Loading records history entries of
+  // its own (`unloadScene` + `setScene`/`clearScene` are tracked writes), so
+  // without this reset a few Ctrl+Z presses could step past the load into the
+  // pre-load — often empty — state and wipe the whole project.
+  clearSceneHistory()
+
   syncEditorSelectionFromCurrentScene()
 }
 

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

@@ -0,0 +1,298 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, nodeRegistry, registerNode } from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  resolveCanvasSelectionNode,
+  resolveNodeSelectionTarget,
+  resolveSelectedIdsForNodeClick,
+  selectionModifiersFromEvent,
+  shouldPreserveSelectedRoofHostTarget,
+} from './selection-routing'
+
+function registerTestDefinition(kind: string, overrides: Record<string, unknown> = {}) {
+  if (nodeRegistry.has(kind)) return
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(kind) }) as never,
+    category: 'furnish',
+    defaults: () => ({ type: kind }) as never,
+    capabilities: {},
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+    ...overrides,
+  } as never)
+}
+
+describe('resolveSelectedIdsForNodeClick', () => {
+  test('preserves the pre-routing selection when a phase switch clears current ids', () => {
+    expect(
+      resolveSelectedIdsForNodeClick({
+        baseSelectedIds: ['wall_1'],
+        currentSelectedIds: [],
+        modifierKeys: { meta: true, ctrl: false, shift: false },
+        nodeId: 'item_1',
+      }),
+    ).toEqual(['wall_1', 'item_1'])
+  })
+
+  test('toggles from the pre-routing selection while a modifier is held', () => {
+    expect(
+      resolveSelectedIdsForNodeClick({
+        baseSelectedIds: ['wall_1', 'item_1'],
+        currentSelectedIds: [],
+        modifierKeys: { meta: false, ctrl: false, shift: true },
+        nodeId: 'item_1',
+      }),
+    ).toEqual(['wall_1'])
+  })
+})
+
+describe('selectionModifiersFromEvent', () => {
+  test('falls back to tracked modifier state when the click event omits keys', () => {
+    expect(selectionModifiersFromEvent({}, { meta: false, ctrl: true, shift: false })).toEqual({
+      meta: false,
+      ctrl: true,
+      shift: false,
+    })
+  })
+
+  test('prefers explicit event key state over stale tracked modifiers', () => {
+    expect(
+      selectionModifiersFromEvent(
+        { metaKey: false, ctrlKey: false, shiftKey: false },
+        { meta: true, ctrl: true, shift: true },
+      ),
+    ).toEqual({
+      meta: false,
+      ctrl: false,
+      shift: false,
+    })
+  })
+})
+
+describe('resolveNodeSelectionTarget', () => {
+  test('routes furniture items to furnish', () => {
+    const node = {
+      id: 'item_1',
+      type: 'item',
+      asset: { category: 'furniture' },
+    } as unknown as AnyNode
+
+    expect(resolveNodeSelectionTarget(node)).toEqual({ phase: 'furnish' })
+  })
+
+  test('routes door and window catalog items to structure', () => {
+    const node = {
+      id: 'item_1',
+      type: 'item',
+      asset: { category: 'door' },
+    } as unknown as AnyNode
+
+    expect(resolveNodeSelectionTarget(node)).toEqual({
+      phase: 'structure',
+      structureLayer: 'elements',
+    })
+  })
+})
+
+describe('resolveCanvasSelectionNode', () => {
+  // Mirrors the cabinet-module setup: modules proxy to their run for grouped
+  // move / rotate, but declare `selectionProxy.bypassDirectPick` so a direct
+  // body click selects the clicked module.
+  const groupKind = 'selection-routing-proxy-group-test'
+  const memberKind = 'selection-routing-proxy-member-test'
+
+  function registerBypassKinds() {
+    registerTestDefinition(groupKind)
+    registerTestDefinition(memberKind, {
+      selectionProxy: {
+        bypassDirectPick: (node: AnyNode, proxyTarget: AnyNode) =>
+          (node.type as string) === memberKind && (proxyTarget.type as string) === groupKind,
+      },
+    })
+  }
+
+  test('keeps proxied members individually selectable when the kind declares bypassDirectPick', () => {
+    registerBypassKinds()
+    const run = { id: 'group_run', type: groupKind, metadata: {} } as unknown as AnyNode
+    const module = {
+      id: 'group_member',
+      type: memberKind,
+      parentId: run.id,
+      metadata: { nodeSelectionProxyId: run.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: module,
+        nodes: {
+          [run.id]: run,
+          [module.id]: module,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(module)
+  })
+
+  test('keeps nested proxied members leaf-selectable by default', () => {
+    registerBypassKinds()
+    const rootRun = { id: 'group_root_run', type: groupKind, metadata: {} } as unknown as AnyNode
+    const legRun = {
+      id: 'group_leg_run',
+      type: groupKind,
+      parentId: rootRun.id,
+      metadata: { nodeSelectionProxyId: rootRun.id },
+    } as unknown as AnyNode
+    const nestedCornerBase = {
+      id: 'group_nested_member',
+      type: memberKind,
+      parentId: legRun.id,
+      metadata: { nodeSelectionProxyId: legRun.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: nestedCornerBase,
+        nodes: {
+          [rootRun.id]: rootRun,
+          [legRun.id]: legRun,
+          [nestedCornerBase.id]: nestedCornerBase,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(nestedCornerBase)
+  })
+
+  test('follows the proxy when the kind declares no bypass', () => {
+    const kind = 'selection-routing-proxy-no-bypass-test'
+    registerTestDefinition(kind)
+    const group = { id: 'plain_group', type: kind, metadata: {} } as unknown as AnyNode
+    const member = {
+      id: 'plain_member',
+      type: kind,
+      parentId: group.id,
+      metadata: { nodeSelectionProxyId: group.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: member,
+        nodes: {
+          [group.id]: group,
+          [member.id]: member,
+        },
+        selectedIds: [],
+      }),
+    ).toBe(group)
+  })
+
+  test('keeps parent-frame children routed to their parent when that parent is solely selected', () => {
+    const kind = 'selection-routing-parent-frame-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+          },
+        },
+      },
+    })
+
+    const parent = { id: 'parent_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const child = {
+      id: 'child_1',
+      type: kind,
+      parentId: parent.id,
+      metadata: {},
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: child,
+        nodes: {
+          [parent.id]: parent,
+          [child.id]: child,
+        },
+        selectedIds: [parent.id],
+      }),
+    ).toBe(parent)
+  })
+
+  test('prefers an explicit selection proxy before parent-frame routing', () => {
+    const kind = 'selection-routing-proxy-before-parent-frame-test'
+    registerTestDefinition(kind, {
+      capabilities: {
+        movable: {
+          axes: ['x', 'z'],
+          gridSnap: true,
+          parentFrame: {
+            resolveParent: (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) =>
+              (node.parentId ? nodes[node.parentId] : null) ?? null,
+          },
+        },
+      },
+    })
+
+    const root = { id: 'root_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const proxyGroup = { id: 'proxy_1', type: groupKind, metadata: {} } as unknown as AnyNode
+    const child = {
+      id: 'child_proxy_1',
+      type: kind,
+      parentId: root.id,
+      metadata: { nodeSelectionProxyId: proxyGroup.id },
+    } as unknown as AnyNode
+
+    expect(
+      resolveCanvasSelectionNode({
+        node: child,
+        nodes: {
+          [root.id]: root,
+          [proxyGroup.id]: proxyGroup,
+          [child.id]: child,
+        },
+        selectedIds: [root.id],
+      }),
+    ).toBe(proxyGroup)
+  })
+})
+
+describe('shouldPreserveSelectedRoofHostTarget', () => {
+  test('keeps the roof host target while that roof is the sole armed selection', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1'],
+        armedRoofId: 'roof_1',
+      }),
+    ).toBe(true)
+  })
+
+  test('falls back to segment targeting when the roof host is not armed', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1'],
+        armedRoofId: null,
+      }),
+    ).toBe(false)
+  })
+
+  test('falls back to segment targeting when the roof is no longer the sole selection', () => {
+    const node = { id: 'roof_1', type: 'roof' } as unknown as AnyNode
+
+    expect(
+      shouldPreserveSelectedRoofHostTarget({
+        node,
+        selectedIds: ['roof_1', 'wall_1'],
+        armedRoofId: 'roof_1',
+      }),
+    ).toBe(false)
+  })
+})

package/src/lib/selection-routing.ts

@@ -0,0 +1,175 @@
+import {
+  type AnyNode,
+  type ItemNode,
+  nodeRegistry,
+  resolveSelectionProxyId,
+} from '@pascal-app/core'
+
+export type SelectionModifierKeys = {
+  meta: boolean
+  ctrl: boolean
+  shift: boolean
+}
+
+export type NodeSelectionTarget = {
+  phase: 'site' | 'structure' | 'furnish'
+  structureLayer?: 'zones' | 'elements'
+}
+
+function shouldBypassSelectionProxy(node: AnyNode, target: AnyNode): boolean {
+  if (node.id === target.id) return false
+  // Kind-declared bypass (`def.selectionProxy.bypassDirectPick`): the kind
+  // keeps a proxy for grouped affordances but wants a direct body click to
+  // select the clicked node itself.
+  return nodeRegistry.get(node.type)?.selectionProxy?.bypassDirectPick?.(node, target) ?? false
+}
+
+export function resolveCanvasSelectionNode({
+  node,
+  nodes,
+  selectedIds,
+}: {
+  node: AnyNode
+  nodes: Readonly<Record<string, AnyNode | undefined>>
+  selectedIds: readonly string[]
+}): AnyNode {
+  const proxiedTarget = nodes[resolveSelectionProxyId(node, nodes)] ?? node
+  let target = shouldBypassSelectionProxy(node, proxiedTarget) ? node : proxiedTarget
+  const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
+  if (parentFrame) {
+    const parent = parentFrame.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
+    if (parent && selectedIds.length === 1 && selectedIds[0] === parent.id) {
+      target = parent
+    }
+  }
+  return target
+}
+
+export function isSelectionModifierActive(keys: SelectionModifierKeys): boolean {
+  return keys.meta || keys.ctrl || keys.shift
+}
+
+export function selectionModifiersFromEvent(
+  event?: {
+    metaKey?: boolean
+    ctrlKey?: boolean
+    shiftKey?: boolean
+    nativeEvent?: {
+      metaKey?: boolean
+      ctrlKey?: boolean
+      shiftKey?: boolean
+    }
+  } | null,
+  fallback?: Partial<SelectionModifierKeys>,
+): SelectionModifierKeys {
+  const fromEvent = (
+    key: keyof SelectionModifierKeys,
+    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey',
+  ) => {
+    if (typeof event?.[eventKey] === 'boolean') return event[eventKey]
+    if (typeof event?.nativeEvent?.[eventKey] === 'boolean') return event.nativeEvent[eventKey]
+    return Boolean(fallback?.[key])
+  }
+
+  return {
+    meta: fromEvent('meta', 'metaKey'),
+    ctrl: fromEvent('ctrl', 'ctrlKey'),
+    shift: fromEvent('shift', 'shiftKey'),
+  }
+}
+
+export function resolveSelectedIdsForNodeClick({
+  baseSelectedIds,
+  currentSelectedIds,
+  modifierKeys,
+  nodeId,
+}: {
+  baseSelectedIds?: readonly string[]
+  currentSelectedIds: readonly string[]
+  modifierKeys: SelectionModifierKeys
+  nodeId: string
+}): string[] {
+  if (isSelectionModifierActive(modifierKeys)) {
+    const selectedIds = baseSelectedIds ?? currentSelectedIds
+    if (selectedIds.includes(nodeId)) {
+      return selectedIds.filter((id) => id !== nodeId)
+    }
+    return [...selectedIds, nodeId]
+  }
+
+  return [nodeId]
+}
+
+export function shouldPreserveSelectedRoofHostTarget({
+  node,
+  selectedIds,
+  armedRoofId,
+}: {
+  node: AnyNode
+  selectedIds: readonly string[]
+  armedRoofId: string | null
+}): boolean {
+  return (
+    node.type === 'roof' &&
+    armedRoofId === node.id &&
+    selectedIds.length === 1 &&
+    selectedIds[0] === node.id
+  )
+}
+
+export function resolveNodeSelectionTarget(node: AnyNode): NodeSelectionTarget | null {
+  if (node.type === 'building') {
+    return { phase: 'site' }
+  }
+
+  if (node.type === 'zone') {
+    return {
+      phase: 'structure',
+      structureLayer: 'zones',
+    }
+  }
+
+  if (node.type === 'item') {
+    const item = node as ItemNode
+    if (item.asset.category === 'door' || item.asset.category === 'window') {
+      return {
+        phase: 'structure',
+        structureLayer: 'elements',
+      }
+    }
+    return { phase: 'furnish' }
+  }
+
+  if (
+    node.type === 'wall' ||
+    node.type === 'fence' ||
+    node.type === 'column' ||
+    node.type === 'elevator' ||
+    node.type === 'slab' ||
+    node.type === 'ceiling' ||
+    node.type === 'roof' ||
+    node.type === 'roof-segment' ||
+    node.type === 'stair' ||
+    node.type === 'stair-segment' ||
+    node.type === 'spawn' ||
+    node.type === 'window' ||
+    node.type === 'door'
+  ) {
+    return {
+      phase: 'structure',
+      structureLayer: 'elements',
+    }
+  }
+
+  const def = nodeRegistry.get(node.type)
+  if (!def) return null
+
+  if (def.category === 'furnish') {
+    return { phase: 'furnish' }
+  }
+
+  return {
+    phase: 'structure',
+    structureLayer: 'elements',
+  }
+}

package/src/lib/sfx/index.ts

@@ -1,2 +1,3 @@
 export { initSFXBus, sfxEmitter, triggerSFX } from '../sfx-bus'
 export { playSFX, SFX, type SFXName, updateSFXVolumes } from '../sfx-player'
+export { movementSfxStepKey } from './movement-tick'