@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/lib/floorplan/geometry.ts

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

package/src/lib/floorplan/index.ts

@@ -8,6 +8,8 @@ export {
 export {
   clampPlanValue,
   doesPolygonIntersectSelectionBounds,
+  FLOORPLAN_VIEW_ROTATION_DEG,
+  floorplanLocalToWorldPoint,
   getDistanceToWallSegment,
   getFloorplanSelectionBounds,
   getPlanPointDistance,
@@ -20,6 +22,7 @@ export {
   movePlanPointTowards,
   pointMatchesWallPlanPoint,
   rotatePlanVector,
+  worldToFloorplanLocalPoint,
 } from './geometry'
 export {
   buildFloorplanItemEntry,

package/src/lib/floorplan/items.ts

@@ -82,7 +82,7 @@ export function getItemFloorplanTransform(
       )
       const wallLocalZ =
         item.asset.attachTo === 'wall-side'
-          ? ((parentNode.thickness ?? 0.1) / 2) * (item.side === 'back' ? -1 : 1)
+          ? ((parentNode.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
           : item.position[2]
       const [offsetX, offsetY] = rotatePlanVector(item.position[0], wallLocalZ, wallRotation)
 
@@ -164,7 +164,10 @@ type Point = {
 
 function getItemDimensionPolygon(item: ItemNode, transform: FloorplanNodeTransform): Point[] {
   const [width, , depth] = getScaledDimensions(item)
-  const centerLocalZ = item.asset.attachTo === 'wall-side' ? -depth / 2 : 0
+  // Wall-side items extend depth-ward away from the wall (into the room); push
+  // the footprint centre a half-depth out along local +Z. A negative offset
+  // would lay the box across the wall onto the far side (mirrored from 3D).
+  const centerLocalZ = item.asset.attachTo === 'wall-side' ? depth / 2 : 0
   const [offsetX, offsetY] = rotatePlanVector(0, centerLocalZ, transform.rotation)
 
   return getRotatedRectanglePolygon(

package/src/lib/floorplan/plan-coords.ts

@@ -0,0 +1,21 @@
+import type { FloorplanAffordancePoint } from '@pascal-app/core'
+
+/**
+ * Convert client (screen) coordinates into floor-plan plan coordinates via
+ * the mounted floor-plan scene `<g>`'s screen CTM. The scene `<g>` maps plan
+ * X/Z directly to SVG x/y (Z stored as the Y axis on screen — same convention
+ * as `toSvgPlanPoint`), so the returned point is in the same level-frame
+ * meters node placements use. Null when no floor plan is mounted.
+ */
+export function clientToPlan(clientX: number, clientY: number): FloorplanAffordancePoint | null {
+  const target = document.querySelector('g[data-floorplan-scene]') as SVGGElement | null
+  const svg = target?.ownerSVGElement
+  if (!(svg && target)) return null
+  const ctm = target.getScreenCTM()
+  if (!ctm) return null
+  const point = svg.createSVGPoint()
+  point.x = clientX
+  point.y = clientY
+  const transformed = point.matrixTransform(ctm.inverse())
+  return [transformed.x, transformed.y]
+}

package/src/lib/fresh-planar-placement.test.ts

@@ -1,7 +1,24 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
-import type { AnyNode, AnyNodeId } from '@pascal-app/core'
-import { useScene } from '@pascal-app/core'
-import { commitFreshPlacementSubtree } from './fresh-planar-placement'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  CabinetModuleNode,
+  CabinetNode,
+  findLevelAncestorId,
+  nodeRegistry,
+  registerNode,
+  type SceneCommit,
+  subscribeSceneCommits,
+  useScene,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import {
+  commitFreshPlacementSubtree,
+  createFreshPlacementSubtree,
+  duplicatesAsFreshSubtree,
+  prepareFreshPlacementRootDuplicate,
+} from './fresh-planar-placement'
 
 type RafFn = (cb: (time: number) => void) => number
 ;(globalThis as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= ((
@@ -14,6 +31,61 @@ type RafFn = (cb: (time: number) => void) => number
 
 const LEVEL_ID = 'level_test' as AnyNodeId
 const SHELF_ID = 'shelf_draft' as AnyNodeId
+const CABINET_RUN_ID = 'cabinet_original-run' as AnyNodeId
+const CABINET_LEFT_ID = 'cabinet-module_original-left' as AnyNodeId
+const CABINET_RIGHT_ID = 'cabinet-module_original-right' as AnyNodeId
+const CABINET_CHILD_RUN_ID = 'cabinet_child-run' as AnyNodeId
+const CABINET_CHILD_MODULE_ID = 'cabinet-module_child-module' as AnyNodeId
+
+function registerCabinetClonePrepTestKind() {
+  if (nodeRegistry.has('cabinet')) return
+
+  registerNode({
+    kind: 'cabinet',
+    schemaVersion: 1,
+    schema: z.any() as never,
+    category: 'furnish',
+    defaults: () => ({}),
+    capabilities: {
+      duplicable: {
+        subtree: true,
+        prepareSubtreeClone: ({ root, descendants, rootId, nodes }) => {
+          const parent = root.parentId ? nodes[root.parentId as AnyNodeId] : null
+          if (root.type !== 'cabinet' || parent?.type !== 'cabinet') {
+            return { root, descendants }
+          }
+          const parentPosition = (parent as { position: [number, number, number] }).position
+          const parentRotation = (parent as { rotation: number }).rotation
+          const childPosition = (root as { position: [number, number, number] }).position
+          const childRotation = (root as { rotation: number }).rotation
+          const cos = Math.cos(parentRotation)
+          const sin = Math.sin(parentRotation)
+          const {
+            cabinetCornerDerivedRun: _derived,
+            nodeSelectionProxyId: _proxy,
+            ...metadata
+          } = (root.metadata ?? {}) as Record<string, unknown>
+          return {
+            root: {
+              ...root,
+              parentId: findLevelAncestorId(rootId, nodes),
+              position: [
+                parentPosition[0] + childPosition[0] * cos + childPosition[2] * sin,
+                parentPosition[1] + childPosition[1],
+                parentPosition[2] - childPosition[0] * sin + childPosition[2] * cos,
+              ],
+              rotation: parentRotation + childRotation,
+              metadata,
+            } as AnyNode,
+            descendants,
+            parentId: findLevelAncestorId(rootId, nodes),
+          }
+        },
+      },
+    },
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+}
 
 function level(children: AnyNodeId[]): AnyNode {
   return {
@@ -53,6 +125,42 @@ function shelf(): AnyNode {
   } as AnyNode
 }
 
+function seedCabinetRun() {
+  const run = CabinetNode.parse({
+    id: CABINET_RUN_ID,
+    parentId: LEVEL_ID,
+    position: [0, 0, 0],
+    rotation: 0,
+    children: [CABINET_LEFT_ID, CABINET_RIGHT_ID],
+    showPlinth: true,
+    withCountertop: true,
+  })
+  const left = CabinetModuleNode.parse({
+    id: CABINET_LEFT_ID,
+    parentId: CABINET_RUN_ID,
+    position: [-0.45, 0.1, 0],
+    width: 0.9,
+  })
+  const right = CabinetModuleNode.parse({
+    id: CABINET_RIGHT_ID,
+    parentId: CABINET_RUN_ID,
+    position: [0.45, 0.1, 0],
+    width: 0.9,
+  })
+
+  useScene.setState({
+    nodes: {
+      [LEVEL_ID]: level([CABINET_RUN_ID]),
+      [CABINET_RUN_ID]: run as AnyNode,
+      [CABINET_LEFT_ID]: left as AnyNode,
+      [CABINET_RIGHT_ID]: right as AnyNode,
+    },
+    rootNodeIds: [LEVEL_ID],
+    collections: {},
+    dirtyNodes: new Set(),
+  } as never)
+}
+
 describe('commitFreshPlacementSubtree', () => {
   beforeEach(() => {
     useScene.setState({
@@ -69,12 +177,15 @@ describe('commitFreshPlacementSubtree', () => {
   })
 
   test('commits a fresh draft as one undoable clean subtree', () => {
+    const commits: SceneCommit[] = []
+    const unsubscribe = subscribeSceneCommits((commit) => commits.push(commit))
     useScene.temporal.getState().pause()
 
     const committedId = commitFreshPlacementSubtree(SHELF_ID, {
       position: [2, 0, 3],
       visible: true,
     } as Partial<AnyNode>)
+    unsubscribe()
 
     expect(committedId).toBeTruthy()
     expect(committedId).not.toBe(SHELF_ID)
@@ -91,6 +202,12 @@ describe('commitFreshPlacementSubtree', () => {
     expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([
       finalId,
     ])
+    expect(commits).toHaveLength(1)
+    expect(commits[0]?.origin).toBe('local')
+    expect(commits[0]?.before.nodes[SHELF_ID]).toBeUndefined()
+    expect(commits[0]?.before.nodes[finalId]).toBeUndefined()
+    expect(commits[0]?.current.nodes[SHELF_ID]).toBeUndefined()
+    expect(commits[0]?.current.nodes[finalId]).toEqual(committed)
 
     useScene.temporal.getState().resume()
     useScene.temporal.getState().undo()
@@ -99,4 +216,167 @@ describe('commitFreshPlacementSubtree', () => {
     expect(useScene.getState().nodes[SHELF_ID]).toBeUndefined()
     expect((useScene.getState().nodes[LEVEL_ID] as { children: AnyNodeId[] }).children).toEqual([])
   })
+
+  test('uses the subtree contract for childless variants and never aliases root-only children', () => {
+    registerCabinetClonePrepTestKind()
+    const childlessCabinet = {
+      ...shelf(),
+      type: 'cabinet',
+      children: [],
+      metadata: { isTransient: true, label: 'source' },
+    } as AnyNode
+    expect(duplicatesAsFreshSubtree(childlessCabinet)).toBe(true)
+
+    const source = {
+      ...shelf(),
+      children: ['item_original' as AnyNodeId],
+      metadata: { isTransient: true, label: 'source' },
+    } as AnyNode
+    const duplicate = prepareFreshPlacementRootDuplicate(source) as AnyNode & {
+      children: AnyNodeId[]
+      id?: AnyNodeId
+      metadata?: Record<string, unknown>
+    }
+
+    expect(duplicate.id).toBeUndefined()
+    expect(duplicate.children).toEqual([])
+    expect(duplicate.metadata).toEqual({ isNew: true, label: 'source' })
+    expect((source as AnyNode & { children: AnyNodeId[] }).children).toEqual(['item_original'])
+  })
+
+  test('commits a duplicated cabinet draft without deleting the original modules', () => {
+    seedCabinetRun()
+    useScene.temporal.getState().clear()
+    useScene.temporal.getState().pause()
+
+    const draftId = createFreshPlacementSubtree(CABINET_RUN_ID)
+    expect(draftId).toBeTruthy()
+    expect(draftId).not.toBe(CABINET_RUN_ID)
+
+    const draft = useScene.getState().nodes[draftId as AnyNodeId] as
+      | (AnyNode & { children: AnyNodeId[]; metadata?: Record<string, unknown> })
+      | undefined
+    expect(draft?.metadata?.isNew).toBe(true)
+    expect(draft?.children).toHaveLength(2)
+    expect(draft?.children).not.toContain(CABINET_LEFT_ID)
+    expect(draft?.children).not.toContain(CABINET_RIGHT_ID)
+
+    const finalId = commitFreshPlacementSubtree(
+      draftId as AnyNodeId,
+      {
+        position: [2, 0, 3],
+        visible: true,
+      } as Partial<AnyNode>,
+    )
+    expect(finalId).toBeTruthy()
+
+    const nodes = useScene.getState().nodes
+    expect(nodes[CABINET_RUN_ID]).toBeDefined()
+    expect(nodes[CABINET_LEFT_ID]).toBeDefined()
+    expect(nodes[CABINET_RIGHT_ID]).toBeDefined()
+
+    const finalRun = nodes[finalId as AnyNodeId] as
+      | (AnyNode & { children: AnyNodeId[]; metadata?: Record<string, unknown> })
+      | undefined
+    expect(finalRun?.children).toHaveLength(2)
+    expect(finalRun?.metadata?.isNew).toBeUndefined()
+    for (const childId of finalRun?.children ?? []) {
+      const child = nodes[childId]
+      expect(child?.type).toBe('cabinet-module')
+      expect(child?.parentId).toBe(finalId)
+    }
+  })
+
+  test('flattens duplicated nested cabinet runs into level coordinates before dragging', () => {
+    registerCabinetClonePrepTestKind()
+    const parentRun = {
+      id: CABINET_RUN_ID,
+      type: 'cabinet',
+      object: 'node',
+      visible: true,
+      metadata: {},
+      parentId: LEVEL_ID,
+      position: [4, 0, 5],
+      rotation: Math.PI / 2,
+      children: [CABINET_LEFT_ID, CABINET_CHILD_RUN_ID],
+      width: 0.6,
+      depth: 0.58,
+      carcassHeight: 0.72,
+      plinthHeight: 0.1,
+      toeKickDepth: 0.075,
+      boardThickness: 0.018,
+      countertopThickness: 0.02,
+      countertopOverhang: 0.02,
+      countertopBackOverhang: 0,
+      withFinishedBack: false,
+      withWaterfall: false,
+      frontThickness: 0.018,
+      frontGap: 0.003,
+      frontStyle: 'slab',
+      handleStyle: 'bar',
+      handlePosition: 'auto',
+      frontOverlay: 'full',
+      withBottomPanel: true,
+      showPlinth: true,
+      withCountertop: true,
+      operationState: 0,
+      runTier: 'base',
+    } as AnyNode
+    const parentModule = CabinetModuleNode.parse({
+      id: CABINET_LEFT_ID,
+      parentId: CABINET_RUN_ID,
+      position: [0.5, 0.1, 0],
+      width: 1,
+    })
+    const childRun = CabinetNode.parse({
+      id: CABINET_CHILD_RUN_ID,
+      parentId: CABINET_RUN_ID,
+      position: [1, 0, 0.25],
+      rotation: Math.PI / 2,
+      children: [CABINET_CHILD_MODULE_ID],
+      metadata: {
+        cabinetCornerDerivedRun: { role: 'base-leg', side: 'right', sourceRunId: CABINET_RUN_ID },
+        nodeSelectionProxyId: CABINET_RUN_ID,
+      },
+    })
+    const childModule = CabinetModuleNode.parse({
+      id: CABINET_CHILD_MODULE_ID,
+      parentId: CABINET_CHILD_RUN_ID,
+      position: [0, 0.1, 0],
+      width: 0.9,
+    })
+    useScene.setState({
+      nodes: {
+        [LEVEL_ID]: level([CABINET_RUN_ID]),
+        [CABINET_RUN_ID]: parentRun as AnyNode,
+        [CABINET_LEFT_ID]: parentModule as AnyNode,
+        [CABINET_CHILD_RUN_ID]: childRun as AnyNode,
+        [CABINET_CHILD_MODULE_ID]: childModule as AnyNode,
+      },
+      rootNodeIds: [LEVEL_ID],
+      collections: {},
+      dirtyNodes: new Set(),
+    } as never)
+
+    const draftId = createFreshPlacementSubtree(CABINET_CHILD_RUN_ID)
+    const draft = useScene.getState().nodes[draftId as AnyNodeId] as
+      | (AnyNode & {
+          children: AnyNodeId[]
+          metadata?: Record<string, unknown>
+          position: [number, number, number]
+          rotation: number
+        })
+      | undefined
+
+    expect(draft).toBeDefined()
+    expect(draft?.parentId).toBe(LEVEL_ID)
+    expect(draft?.position[0]).toBeCloseTo(4.25)
+    expect(draft?.position[2]).toBeCloseTo(4)
+    expect(draft?.rotation).toBeCloseTo(Math.PI)
+    expect(draft?.metadata?.isNew).toBe(true)
+    expect(draft?.metadata?.cabinetCornerDerivedRun).toBeUndefined()
+    expect(draft?.metadata?.nodeSelectionProxyId).toBeUndefined()
+    expect(draft?.children).toHaveLength(1)
+    expect(draft?.children).not.toContain(CABINET_CHILD_MODULE_ID)
+  })
 })

package/src/lib/fresh-planar-placement.ts

@@ -3,9 +3,11 @@ import {
   type AnyNodeId,
   cloneNodesInto,
   collectSubtree,
+  type DuplicableConfig,
+  nodeRegistry,
   useScene,
 } from '@pascal-app/core'
-import { stripPlacementMetadataFlags } from './placement-metadata'
+import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
 
 function cleanPlacementMetadata<N extends AnyNode>(node: N): N {
   return {
@@ -19,6 +21,88 @@ function parentIdOf(node: AnyNode): AnyNodeId | undefined {
   return parentId ?? undefined
 }
 
+function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
+  const duplicable = nodeRegistry.get(node.type)?.capabilities?.duplicable
+  return duplicable && typeof duplicable === 'object' ? duplicable : null
+}
+
+export function duplicatesAsFreshSubtree(node: AnyNode): boolean {
+  return duplicableConfigFor(node)?.subtree === true
+}
+
+/**
+ * Prepares a non-subtree duplicate without retaining ownership of the
+ * original node's children. Subtree-capable kinds take the path above and
+ * receive fresh descendant IDs; every other kind duplicates only its root.
+ */
+export function prepareFreshPlacementRootDuplicate(node: AnyNode): AnyNode {
+  const duplicate = structuredClone(node) as unknown as Record<string, unknown> & {
+    id?: AnyNodeId
+    children?: unknown
+    metadata?: unknown
+  }
+  delete duplicate.id
+  if (Array.isArray(duplicate.children)) duplicate.children = []
+  duplicate.metadata = {
+    ...getPlacementMetadataRecord(stripPlacementMetadataFlags(duplicate.metadata)),
+    isNew: true,
+  }
+  return duplicate as unknown as AnyNode
+}
+
+/**
+ * Creates a fresh draft copy of a live subtree, with every child reference
+ * rewired before move mode starts.
+ */
+export function createFreshPlacementSubtree(
+  rootId: AnyNodeId,
+  rootPatch: Partial<AnyNode> = {},
+): AnyNodeId | null {
+  const scene = useScene.getState()
+  const subtree = collectSubtree(scene.nodes, rootId)
+  if (!subtree) return null
+
+  const baseRoot = {
+    ...subtree.root,
+    ...rootPatch,
+  } as AnyNode
+  const prepared = duplicableConfigFor(subtree.root)?.prepareSubtreeClone?.({
+    root: baseRoot,
+    descendants: subtree.descendants,
+    rootId,
+    rootPatch,
+    nodes: scene.nodes,
+  })
+  const preparedRoot = prepared?.root ?? baseRoot
+  const root = {
+    ...preparedRoot,
+    metadata: {
+      ...getPlacementMetadataRecord(stripPlacementMetadataFlags(preparedRoot.metadata)),
+      isNew: true,
+    },
+  } as AnyNode
+  const descendants = (prepared?.descendants ?? subtree.descendants).map((node: AnyNode) => ({
+    ...node,
+    metadata: stripPlacementMetadataFlags(node.metadata),
+  })) as AnyNode[]
+  const parentId =
+    prepared && Object.hasOwn(prepared, 'parentId')
+      ? (prepared.parentId ?? undefined)
+      : parentIdOf(root)
+  const cloned = cloneNodesInto([root, ...descendants], {
+    rootId,
+    parentId,
+  })
+
+  useScene
+    .getState()
+    .createNodes(
+      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
+    )
+
+  return cloned.rootId
+}
+
 /**
  * Finalises a fresh catalog/duplicate draft as a single undoable creation.
  *