@pascal-app/editor 1.0.0 → 1.0.1

package/src/components/tools/shared/shelf-stickiness.ts

@@ -0,0 +1,54 @@
+import {
+  type AnyNodeId,
+  createSceneApi,
+  getSurfaceProvider,
+  sceneRegistry,
+  surfaceRegionContainsPoint,
+  useScene,
+} from '@pascal-app/core'
+import { Box3, type Camera, Matrix4, Ray, Vector3 } from 'three'
+
+export function createShelfStickiness() {
+  const ray = new Ray()
+  const box = new Box3()
+  const matrix = new Matrix4()
+  const cameraPosition = new Vector3()
+
+  // A ray through a board gap can hit the floor behind the shelf while still targeting its volume.
+  return (
+    shelfId: string | null | undefined,
+    camera: Camera,
+    worldPoint: readonly [number, number, number],
+  ) => {
+    if (!shelfId) return false
+    const mesh = sceneRegistry.nodes.get(shelfId)
+    const shelf = useScene.getState().nodes[shelfId as AnyNodeId]
+    if (!mesh || !shelf || (shelf.type !== 'shelf' && shelf.type !== 'cabinet')) return false
+    camera.getWorldPosition(cameraPosition)
+    ray.origin.copy(cameraPosition)
+    ray.direction
+      .set(...worldPoint)
+      .sub(cameraPosition)
+      .normalize()
+    ray.applyMatrix4(matrix.copy(mesh.matrixWorld).invert())
+    if (shelf.type === 'cabinet') {
+      const surfaces =
+        getSurfaceProvider(shelf).surfaces?.(shelf, { scene: createSceneApi(useScene) }) ?? []
+      return surfaces.some((surface) => {
+        if (Math.abs(ray.direction.y) < 1e-8) return false
+        const distance = (surface.position[1] - ray.origin.y) / ray.direction.y
+        if (distance < 0) return false
+        const point = ray.at(distance, new Vector3())
+        return surfaceRegionContainsPoint(surface.region, [
+          point.x - surface.position[0],
+          point.z - surface.position[2],
+        ])
+      })
+    }
+    if (!shelf.width || !shelf.depth || !shelf.height) return false
+    const margin = 0.08
+    box.min.set(-shelf.width / 2 - margin, -margin, -shelf.depth / 2 - margin)
+    box.max.set(shelf.width / 2 + margin, shelf.height + margin, shelf.depth / 2 + margin)
+    return ray.intersectsBox(box)
+  }
+}

package/src/components/tools/shared/surface-hit.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, expect, test } from 'bun:test'
+import { type ItemEvent, ItemNode, sceneRegistry } from '@pascal-app/core'
+import { Group, Matrix3, Vector3 } from 'three'
+import { itemEventToSurfaceHit } from './surface-hit'
+
+const host = ItemNode.parse({
+  id: 'item_hit-adapter',
+  asset: { id: 'host', name: 'Host', category: 'furniture', thumbnail: '', src: '/host.glb' },
+})
+
+afterEach(() => sceneRegistry.nodes.delete(host.id))
+
+test('matches the legacy host-local point and hit-mesh normal exactly under rotation and scale', () => {
+  const mesh = new Group()
+  mesh.position.set(4.3, 2.1, -3.7)
+  mesh.rotation.set(0.2, 0.7, -0.1)
+  mesh.scale.set(2, 0.7, 1.3)
+  const object = new Group()
+  object.name = 'surface-mesh'
+  object.position.set(0.4, 0.8, -0.2)
+  object.rotation.set(-0.1, 0.3, 0.2)
+  object.scale.set(0.8, 1.4, 0.6)
+  mesh.add(object)
+  mesh.updateMatrixWorld(true)
+  sceneRegistry.nodes.set(host.id, mesh)
+  const event = {
+    node: host,
+    object,
+    position: object.localToWorld(new Vector3(0.37, 0.81, -0.39)).toArray(),
+    localPosition: [0.37, 0.81, -0.39],
+    normal: [0.2, 1, -0.3],
+    nativeEvent: {} as ItemEvent['nativeEvent'],
+    stopPropagation() {},
+  } as ItemEvent
+  const before = structuredClone({ position: event.position, normal: event.normal })
+  const expectedPoint = mesh.worldToLocal(new Vector3(...event.position)).toArray()
+  const expectedNormal = new Vector3(...event.normal!)
+    .applyNormalMatrix(new Matrix3().getNormalMatrix(object.matrixWorld))
+    .normalize().y
+  const hit = itemEventToSurfaceHit(host, event)!
+  expect(hit.point).toEqual(expectedPoint)
+  expect(hit.point).not.toEqual(event.localPosition)
+  expect(hit.normalWorldY).toBe(expectedNormal)
+  expect(hit.meshName).toBe(object.name)
+  expect({ position: event.position, normal: event.normal }).toEqual(before)
+
+  const roundTrip = mesh.localToWorld(new Vector3(...expectedPoint)).toArray()
+  expect(itemEventToSurfaceHit(host, { ...event, position: roundTrip })!.point).toEqual(
+    mesh.worldToLocal(new Vector3(...roundTrip)).toArray(),
+  )
+  expect(itemEventToSurfaceHit(host, { ...event, normal: undefined })!.normalWorldY).toBeNaN()
+})
+
+test('a missing registered host mesh yields no hit', () => {
+  expect(itemEventToSurfaceHit(host, {} as ItemEvent)).toBeNull()
+})

package/src/components/tools/shared/surface-hit.ts

@@ -0,0 +1,23 @@
+import { type AnyNode, type NodeEvent, type SurfaceHit, sceneRegistry } from '@pascal-app/core'
+import { Matrix3, type Matrix4, Vector3 } from 'three'
+
+export function surfaceWorldNormalY(
+  normal: NodeEvent<AnyNode>['normal'],
+  matrixWorld: Matrix4,
+): number {
+  return normal
+    ? new Vector3(...normal)
+        .applyNormalMatrix(new Matrix3().getNormalMatrix(matrixWorld))
+        .normalize().y
+    : Number.NaN
+}
+
+export function itemEventToSurfaceHit(host: AnyNode, event: NodeEvent<AnyNode>): SurfaceHit | null {
+  const mesh = sceneRegistry.nodes.get(host.id)
+  if (!mesh) return null
+  return {
+    point: mesh.worldToLocal(new Vector3(...event.position)).toArray(),
+    normalWorldY: surfaceWorldNormalY(event.normal, event.object.matrixWorld),
+    meshName: event.object.name,
+  }
+}

package/src/components/tools/shared/surface-rejection.test.tsx

@@ -0,0 +1,106 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  ItemNode,
+  nodeRegistry,
+  registerNode,
+  resolveSurfacePlacement,
+  type SceneApi,
+  type SurfaceProvider,
+  type SurfaceRejectReason,
+} from '@pascal-app/core'
+import { createSurfaceRejectionFeedback } from './surface-rejection'
+
+let restore: () => void
+beforeEach(() => {
+  restore = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+})
+afterEach(() => restore())
+
+for (const reason of [
+  'footprint-outside-surface',
+  'footprint-exceeds-host',
+  'surface-cutout',
+  'child-not-accepted',
+  'host-not-eligible',
+  'no-surface',
+  'invalid-hit',
+] as const) {
+  test(`${reason} remains available from onReject without user-facing text`, () => {
+    const provider: SurfaceProvider = {
+      childFrame: 'host-local',
+      resolveHit: () =>
+        reason === 'no-surface'
+          ? null
+          : {
+              id: 'top',
+              position: [0, 1, 0],
+              normal: [0, 1, 0],
+              region: {
+                kind: 'rect',
+                size: [1, 1],
+                ...(reason === 'surface-cutout'
+                  ? {
+                      holes: [
+                        [
+                          [-0.2, -0.2],
+                          [0.2, -0.2],
+                          [0.2, 0.2],
+                          [-0.2, 0.2],
+                        ],
+                      ],
+                    }
+                  : {}),
+              },
+            },
+      accepts: () => reason !== 'child-not-accepted',
+    }
+    registerNode({
+      kind: 'test-host',
+      schemaVersion: 1,
+      schema: ItemNode,
+      category: 'furnish',
+      defaults: () => ({}),
+      capabilities:
+        reason === 'footprint-exceeds-host'
+          ? { dragBounds: () => ({ size: [0.1, 1, 0.1] }) }
+          : { surfaces: { hosting: provider } },
+    })
+    const feedback = createSurfaceRejectionFeedback()
+    expect(
+      resolveSurfacePlacement({
+        host: {
+          id: 'test_host',
+          type: reason === 'host-not-eligible' ? 'guide' : 'test-host',
+        } as unknown as AnyNode,
+        childKind: 'item',
+        childFootprint: {
+          size: reason === 'footprint-outside-surface' ? [3, 1, 3] : [0.3, 0.3, 0.3],
+          rotationY: 0,
+        },
+        hit: {
+          point: [reason.startsWith('footprint-') ? 2 : 0, reason === 'invalid-hit' ? NaN : 1, 0],
+          normalWorldY: 1,
+        },
+        scene: { get: () => undefined, nodes: () => ({}) } as unknown as SceneApi,
+        onReject: (r) => feedback.reject(r),
+      }),
+    ).toBeNull()
+    expect(feedback.reason).toBe(reason)
+  })
+}
+
+test('the paired grid cannot erase a refusal; a new floor move and cleanup clear it', () => {
+  const changes: (SurfaceRejectReason | null)[] = []
+  const feedback = createSurfaceRejectionFeedback((r) => changes.push(r))
+  const event = {}
+  feedback.reject('footprint-exceeds-host', event)
+  feedback.grid(event)
+  expect(feedback.reason).toBe('footprint-exceeds-host')
+  feedback.grid({})
+  expect(feedback.reason).toBeNull()
+  feedback.reject('surface-cutout', event)
+  feedback.clear()
+  expect(changes).toEqual(['footprint-exceeds-host', null, 'surface-cutout', null])
+})

package/src/components/tools/shared/surface-rejection.tsx

@@ -0,0 +1,29 @@
+import type { SurfaceRejectReason } from '@pascal-app/core'
+
+export function createSurfaceRejectionFeedback(
+  onChange?: (reason: SurfaceRejectReason | null) => void,
+) {
+  let reason: SurfaceRejectReason | null = null
+  let rejectedEvent: object | undefined
+  const set = (next: SurfaceRejectReason | null) => {
+    reason = next
+    onChange?.(next)
+  }
+  return {
+    get reason() {
+      return reason
+    },
+    reject(next: SurfaceRejectReason, event?: object) {
+      if (event) rejectedEvent = event
+      set(next)
+    },
+    clear() {
+      rejectedEvent = undefined
+      set(null)
+    },
+    grid(event: object) {
+      // A host refusal and the floor ray beneath it belong to the same pointer move.
+      if (event !== rejectedEvent) this.clear()
+    },
+  }
+}

package/src/components/tools/zone/zone-tool.tsx

@@ -3,6 +3,7 @@ import {
   emitter,
   type GridEvent,
   type LevelNode,
+  runAsSingleSceneHistoryStep,
   snapPointAlongAngleRay,
   useScene,
   ZoneNode,
@@ -16,6 +17,7 @@ import {
   clearSurfacePlanSnapFeedback,
   resolveSurfacePlanPointSnap,
 } from './../../../lib/surface-plan-snap'
+import { focusedUnitNode } from './../../../lib/units'
 import { snapWorldXZForActiveBuilding } from './../../../lib/world-grid-snap'
 import useEditor, { isAngleSnapActive, isGridSnapActive } from './../../../store/use-editor'
 import { useFloorplanDraftPreview } from './../../../store/use-floorplan-draft-preview'
@@ -27,7 +29,7 @@ const Y_OFFSET = 0.02
  * Creates a zone with the given polygon points
  */
 const commitZoneDrawing = (levelId: LevelNode['id'], points: Array<[number, number]>) => {
-  const { createNode, nodes } = useScene.getState()
+  const { createNode, updateNode, nodes } = useScene.getState()
 
   // Count existing zones for naming and color cycling
   const zoneCount = Object.values(nodes).filter((n) => n.type === 'zone').length
@@ -42,10 +44,17 @@ const commitZoneDrawing = (levelId: LevelNode['id'], points: Array<[number, numb
     color,
   })
 
-  createNode(zone, levelId)
+  const focusedUnit = focusedUnitNode()
 
-  // Select the newly created zone
-  useViewer.getState().setSelection({ zoneId: zone.id })
+  // Joining the focused unit rides in the zone's own undo step.
+  runAsSingleSceneHistoryStep(useScene, () => {
+    createNode(zone, levelId)
+    if (focusedUnit) updateNode(focusedUnit.id, { members: [...focusedUnit.members, zone.id] })
+  })
+
+  // Selecting the zone would end unit focus; while painting a unit the new
+  // zone just joins it and drawing continues.
+  if (!focusedUnit) useViewer.getState().setSelection({ zoneId: zone.id })
 
   // Play structure build sound
   sfxEmitter.emit('sfx:structure-build')

package/src/components/ui/command-palette/editor-commands.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import type { AnyNodeId } from '@pascal-app/core'
-import { DEFAULT_LEVEL_HEIGHT, LevelNode, useScene } from '@pascal-app/core'
+import { DEFAULT_LEVEL_HEIGHT, LevelNode, type UnitNode, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import {
   AppWindow,
@@ -15,6 +15,7 @@ import {
   EyeOff,
   FileJson,
   Grid3X3,
+  Group,
   Hexagon,
   Layers,
   Map,
@@ -39,6 +40,7 @@ import {
 import { useEffect } from 'react'
 import { getHistoryCommandState, runRedo, runUndo } from '../../../lib/history'
 import { deleteLevelWithFallbackSelection } from '../../../lib/level-selection'
+import { createUnitInBuilding, enterUnitFocus, leaveUnitFocus } from '../../../lib/units'
 import { useCommandRegistry } from '../../../store/use-command-registry'
 import type { StructureTool } from '../../../store/use-editor'
 import useEditor from '../../../store/use-editor'
@@ -56,13 +58,25 @@ export function EditorCommands() {
   const setPreviewMode = useEditor((s) => s.setPreviewMode)
 
   const exportScene = useViewer((s) => s.exportScene)
+  // Focusable units are listed one command each; the key changes only when a
+  // unit is added, removed or renamed.
+  const unitListKey = useScene((s) =>
+    Object.values(s.nodes)
+      .filter((n): n is UnitNode => n.type === 'unit')
+      .map((n) => `${n.id}:${n.name ?? ''}`)
+      .join('|'),
+  )
 
   // Re-register when exportScene availability changes (it's a conditional action)
   useEffect(() => {
+    void unitListKey
     const run = (fn: () => void) => {
       fn()
       setOpen(false)
     }
+    const focusableUnits = Object.values(useScene.getState().nodes).filter(
+      (n): n is UnitNode => n.type === 'unit',
+    )
 
     const activateTool = (tool: StructureTool) => {
       run(() => {
@@ -249,6 +263,44 @@ export function EditorCommands() {
           }),
       },
 
+      // ── Units ────────────────────────────────────────────────────────────
+      {
+        id: 'editor.unit.new',
+        label: 'New unit',
+        group: 'Units',
+        icon: <Group className="h-4 w-4" />,
+        keywords: ['unit', 'apartment', 'hotel', 'room', 'add', 'create', 'new'],
+        when: () => Object.values(useScene.getState().nodes).some((n) => n.type === 'building'),
+        execute: () =>
+          run(() => {
+            const { nodes } = useScene.getState()
+            const selectedBuildingId = useViewer.getState().selection.buildingId
+            const building =
+              (selectedBuildingId ? nodes[selectedBuildingId] : undefined) ??
+              Object.values(nodes).find((n) => n.type === 'building')
+            if (building?.type !== 'building') return
+            createUnitInBuilding(building.id)
+          }),
+      },
+      ...focusableUnits.map((unit) => ({
+        id: `editor.unit.focus.${unit.id}`,
+        label: `Focus unit: ${unit.name || 'Unit'}`,
+        group: 'Units',
+        icon: <Group className="h-4 w-4" />,
+        keywords: ['unit', 'focus', 'apartment', unit.name || 'Unit'],
+        when: () => useViewer.getState().focusedUnitId !== unit.id,
+        execute: () => run(() => enterUnitFocus(unit.id)),
+      })),
+      {
+        id: 'editor.unit.exit-focus',
+        label: 'Exit unit focus',
+        group: 'Units',
+        icon: <Group className="h-4 w-4" />,
+        keywords: ['unit', 'focus', 'exit', 'leave', 'apartment'],
+        when: () => !!useViewer.getState().focusedUnitId,
+        execute: () => run(() => leaveUnitFocus()),
+      },
+
       // ── Viewer Controls ──────────────────────────────────────────────────
       {
         id: 'editor.viewer.wall-mode',
@@ -431,6 +483,7 @@ export function EditorCommands() {
     isPreviewMode,
     setPreviewMode,
     exportScene,
+    unitListKey,
   ])
 
   return null

package/src/components/ui/controls/metric-control.tsx

@@ -2,11 +2,7 @@
 
 import { useScene } from '@pascal-app/core'
 import { useCallback, useEffect, useRef, useState } from 'react'
-import {
-  lingoUnitSpec,
-  measurementHint,
-  parseMeasurement,
-} from '../../../lib/measurement-parser'
+import { lingoUnitSpec, measurementHint, parseMeasurement } from '../../../lib/measurement-parser'
 import { useLinearDisplay } from '../../../lib/use-linear-display'
 import { cn } from '../../../lib/utils'
 
@@ -31,8 +27,8 @@ export function MetricControl({
   onCommit,
   min = Number.NEGATIVE_INFINITY,
   max = Number.POSITIVE_INFINITY,
-  precision = 2,
-  step = 1,
+  precision: storedPrecision = 2,
+  step: storedStep = 1,
   className,
   unit = '',
   restoreOnCommit = true,
@@ -40,9 +36,12 @@ export function MetricControl({
   const {
     isImperial,
     displayUnit,
+    parseUnit,
+    precision,
+    step,
     toDisplay: toDisplayValue,
     toStored: toStoredValue,
-  } = useLinearDisplay(unit, precision)
+  } = useLinearDisplay(unit, storedPrecision, storedStep)
 
   const clamp = useCallback(
     (val: number) => {
@@ -110,7 +109,14 @@ export function MetricControl({
 
     container.addEventListener('wheel', handleWheel, { passive: false })
     return () => container.removeEventListener('wheel', handleWheel)
-  }, [isEditing, step, clamp, applyCommittedValue, toStoredValue, roundStoredValueForDisplayPrecision])
+  }, [
+    isEditing,
+    step,
+    clamp,
+    applyCommittedValue,
+    toStoredValue,
+    roundStoredValueForDisplayPrecision,
+  ])
 
   useEffect(() => {
     if (!isHovered || isEditing) return
@@ -226,7 +232,7 @@ export function MetricControl({
     const spec = lingoUnitSpec(unit)
     let stored = spec
       ? parseMeasurement(inputValue, spec, {
-          bareUnit: isImperial ? 'ft' : spec.unitId,
+          bareUnit: parseUnit ?? spec.unitId,
           system: isImperial ? 'us' : 'metric',
         })
       : null
@@ -244,6 +250,7 @@ export function MetricControl({
     inputValue,
     unit,
     isImperial,
+    parseUnit,
     applyCommittedValue,
     clamp,
     toStoredValue,
@@ -256,9 +263,9 @@ export function MetricControl({
   const hint =
     isEditing && spec
       ? measurementHint(inputValue, spec, {
-          bareUnit: isImperial ? 'ft' : spec.unitId,
+          bareUnit: parseUnit ?? spec.unitId,
           system: isImperial ? 'us' : 'metric',
-          displayUnit: isImperial ? 'ft' : spec.unitId,
+          displayUnit: parseUnit ?? spec.unitId,
           precision,
           clamp,
         })
@@ -287,7 +294,16 @@ export function MetricControl({
         setInputValue(toDisplayValue(newV).toFixed(precision))
       }
     },
-    [submitValue, value, toDisplayValue, precision, step, clamp, applyCommittedValue, toStoredValue],
+    [
+      submitValue,
+      value,
+      toDisplayValue,
+      precision,
+      step,
+      clamp,
+      applyCommittedValue,
+      toStoredValue,
+    ],
   )
 
   return (

package/src/components/ui/controls/slider-control.tsx

@@ -2,11 +2,7 @@
 
 import { useScene } from '@pascal-app/core'
 import { useCallback, useEffect, useRef, useState } from 'react'
-import {
-  lingoUnitSpec,
-  measurementHint,
-  parseMeasurement,
-} from '../../../lib/measurement-parser'
+import { lingoUnitSpec, measurementHint, parseMeasurement } from '../../../lib/measurement-parser'
 import { useLinearDisplay } from '../../../lib/use-linear-display'
 import { cn } from '../../../lib/utils'
 
@@ -60,19 +56,16 @@ export function SliderControl({
   onCommit,
   min = Number.NEGATIVE_INFINITY,
   max = Number.POSITIVE_INFINITY,
-  precision = 0,
-  step = 1,
+  precision: storedPrecision = 0,
+  step: storedStep = 1,
   className,
   unit = '',
   restoreOnCommit = true,
   mixed = false,
 }: SliderControlProps) {
-  // Display/storage conversion so the value honors the metric/imperial toggle.
-  // `value`, `onChange`, `onCommit`, `min`/`max`/`clamp` are always in the
-  // stored unit (meters for `unit === 'm'`); the step, drag deltas, text field
-  // and rendered number are in the DISPLAY unit (feet when imperial). For
-  // metric and non-length units these conversions are the identity.
-  const { isImperial, displayUnit, toDisplay, toStored } = useLinearDisplay(unit, precision)
+  // Values and bounds stay in meters; gestures and input use the displayed unit.
+  const { isImperial, displayUnit, parseUnit, precision, step, toDisplay, toStored } =
+    useLinearDisplay(unit, storedPrecision, storedStep)
 
   const [isEditing, setIsEditing] = useState(false)
   const [isDragging, setIsDragging] = useState(false)
@@ -106,7 +99,9 @@ export function SliderControl({
     (storedValue: number, displayDelta: number, displayStep: number) =>
       clamp(
         toStored(
-          Number.parseFloat((toDisplay(storedValue) + displayDelta).toFixed(stepPrecision(displayStep))),
+          Number.parseFloat(
+            (toDisplay(storedValue) + displayDelta).toFixed(stepPrecision(displayStep)),
+          ),
         ),
       ),
     [clamp, toDisplay, toStored],
@@ -231,7 +226,7 @@ export function SliderControl({
     const spec = lingoUnitSpec(unit)
     let stored = spec
       ? parseMeasurement(inputValue, spec, {
-          bareUnit: isImperial ? 'ft' : spec.unitId,
+          bareUnit: parseUnit ?? spec.unitId,
           system: isImperial ? 'us' : 'metric',
         })
       : null
@@ -248,15 +243,27 @@ export function SliderControl({
       onCommit?.(nextValue)
     }
     setIsEditing(false)
-  }, [inputValue, unit, isImperial, onChange, onCommit, clamp, precision, value, toDisplay, toStored])
+  }, [
+    inputValue,
+    unit,
+    isImperial,
+    parseUnit,
+    onChange,
+    onCommit,
+    clamp,
+    precision,
+    value,
+    toDisplay,
+    toStored,
+  ])
 
   const spec = lingoUnitSpec(unit)
   const hint =
     isEditing && spec
       ? measurementHint(inputValue, spec, {
-          bareUnit: isImperial ? 'ft' : spec.unitId,
+          bareUnit: parseUnit ?? spec.unitId,
           system: isImperial ? 'us' : 'metric',
-          displayUnit: isImperial ? 'ft' : spec.unitId,
+          displayUnit: parseUnit ?? spec.unitId,
           precision,
           clamp,
         })