@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/lot/drop-in.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
-import { type AnyNodeId, type SiteNode, useScene } from '@pascal-app/core'
+import { type AnyNodeId, generateId, SiteNode, useScene } from '@pascal-app/core'
 import { dropInLot } from './drop-in'
 import type { ParcelResolveData } from './lot-patch'
 import type { ParcelProvider } from './parcel-provider'
@@ -245,6 +245,64 @@ describe('dropInLot onto a site that already has a lot', () => {
     useScene.setState({ nodes: {}, rootNodeIds: [], dirtyNodes: new Set() } as never)
   })
 
+  test('a terrain response applies the parcel to the hydrated site and preserves its current settings', async () => {
+    let finishTerrain!: () => void
+    let startedTerrain!: () => void
+    const waiting = new Promise<void>((resolve) => {
+      finishTerrain = resolve
+    })
+    const started = new Promise<void>((resolve) => {
+      startedTerrain = resolve
+    })
+    const read = fakeProvider(null, 'sloped')
+    const provider: ParcelProvider = async (endpoint, request) => {
+      if (endpoint === 'elevation') {
+        startedTerrain()
+        await waiting
+      }
+      return read(endpoint, request)
+    }
+    const dropping = dropInLot(
+      { address: GAINESVILLE },
+      {
+        dossier: false,
+        roads: false,
+        provider,
+      },
+    )
+    await started
+    expect(useScene.getState().rootNodeIds).toEqual([])
+    const hydrated = SiteNode.parse({
+      id: generateId('site'),
+      type: 'site',
+      name: 'My site',
+      polygon: { type: 'polygon', points: rect(30, 30) },
+      setbacks: { front: 8, side: 3, rear: 6 },
+      zone: 'Owner verified zone',
+      metadata: { ownerNote: 'Keep the driveway' },
+    })
+    useScene.setState({ nodes: { [hydrated.id]: hydrated }, rootNodeIds: [hydrated.id] } as never)
+    finishTerrain()
+
+    const result = await dropping
+    expect(result.ok).toBe(true)
+    expect(result.siteId).toBe(hydrated.id)
+    expect(useScene.getState().rootNodeIds).toEqual([hydrated.id])
+    const current = site(hydrated.id)
+    const points = current.polygon!.points
+    expect(Math.max(...points.map((p) => p[0])) - Math.min(...points.map((p) => p[0]))).toBe(25)
+    expect(Math.max(...points.map((p) => p[1])) - Math.min(...points.map((p) => p[1]))).toBe(32)
+    expect(current.parcel?.apn).toBe('06075-030-062')
+    expect(current.address?.city).toBe('Gainesville')
+    expect(current.terrain).toBeDefined()
+    expect(current.setbacks).toEqual(hydrated.setbacks)
+    expect(current.zone).toBe(hydrated.zone)
+    expect(current.metadata).toMatchObject({
+      ownerNote: 'Keep the driveway',
+      terrainSample: result.terrain,
+    })
+  })
+
   test('the second lot replaces the first lot’s address, APN and county', async () => {
     const provider = fakeProvider(null)
     const first = await dropInLot({ address: LAKELAND }, { ...offline, provider })

package/src/lib/lot/drop-in.ts

@@ -9,12 +9,12 @@
  *   3. `sitePatchFromParcel` — the site node patch: ring, address,
  *      provenance, the street-facing front edge, planning-default setbacks
  *      when the site has none, north up.
- *   4. The scene's site node is updated (created at the root when the scene
- *      has none) and a building that fell outside the new ring is
- *      re-centred on it — `building.position` only, never the walls.
- *   5. `elevation` — USGS ground over the lot into the site's
+ *   4. `elevation` — USGS ground over the lot into the site's
  *      heightfield (`site.terrain`, terrain.ts; fail-soft, flat lots write
  *      nothing), so a foundation can read the hill.
+ *   5. The parcel and terrain are applied to the current site together
+ *      (created at the root when the scene has none). A building outside
+ *      the new ring is re-centred — `building.position` only, never the walls.
  *
  * Used by the Lot rail panel, the Generate panel (drop in, then generate)
  * and the Site inspector's "Find parcel", so every path behaves the same.
@@ -271,71 +271,63 @@ export async function dropInLot(
     roadsFailure = 'skipped'
   }
 
-  const scene = useScene.getState()
-  let site = findSiteNode(options.siteId)
-  if (!site) {
-    site = SiteNode.parse({ id: generateId('site'), type: 'site', name: 'Site' })
-    scene.createNodes([{ node: site as AnyNode }])
-  }
-  const computed = sitePatchFromParcel(site, input, data, roads, undefined, extras)
-  if (!computed)
+  const geometry = sitePatchFromParcel(null, input, data, roads, undefined, extras)
+  if (!geometry)
     return {
       ok: false,
       error: 'parcel geometry was unusable',
       message: 'The parcel geometry was unusable.',
     }
-  // the surveyed contour lines ride the site with the patch (the site plan
-  // draws them over the heightfield's own); absent without 3DEP lines
-  const contours = dossier && dossierOrigin ? contourLinesFromDossier(dossier, dossierOrigin) : null
-  useScene
-    .getState()
-    .updateNode(
-      site.id as AnyNodeId,
-      { ...computed.patch, terrainContours: contours ?? undefined } as Partial<AnyNode>,
-    )
-
   // The ground over the lot — fail-soft. A sloping lot writes the
   // heightfield; a flat one (or a failed read) clears any terrain the
   // previous lot left behind so the site never shows another parcel's hill.
   let terrain: TerrainSampleSummary | null = null
   let terrainFailure = ''
+  let terrainRead: TerrainSampleResult | null = null
   if (options.terrain !== false) {
-    const read: TerrainSampleResult = data.originLngLat
-      ? await sampleLotTerrain(computed.patch.polygon?.points ?? [], data.originLngLat, {
+    terrainRead = data.originLngLat
+      ? await sampleLotTerrain(geometry.patch.polygon?.points ?? [], data.originLngLat, {
           provider,
           ...(options.terrainDeadlineMs ? { deadlineMs: options.terrainDeadlineMs } : {}),
         })
       : { ok: false, reason: 'no parcel origin' }
-    const current = useScene.getState().nodes[site.id as AnyNodeId]
-    const { terrainSample: _previous, ...meta } =
-      current &&
-      typeof current.metadata === 'object' &&
-      current.metadata !== null &&
-      !Array.isArray(current.metadata)
-        ? (current.metadata as Record<string, unknown>)
-        : {}
-    if (read.ok && read.summary) {
-      terrain = read.summary
-      useScene.getState().updateNode(
-        site.id as AnyNodeId,
-        {
-          terrain: read.terrain,
-          metadata: { ...meta, terrainSample: read.summary },
-        } as unknown as Partial<AnyNode>,
-      )
-    } else {
-      terrainFailure = read.reason ?? 'no terrain'
-      useScene
-        .getState()
-        .updateNode(
-          site.id as AnyNodeId,
-          { terrain: undefined, metadata: meta } as unknown as Partial<AnyNode>,
-        )
-    }
+    if (terrainRead.ok && terrainRead.summary) terrain = terrainRead.summary
+    else terrainFailure = terrainRead.reason ?? 'no terrain'
   } else {
     terrainFailure = 'skipped'
   }
 
+  // Hydration or a person's edit can replace the site while the providers run.
+  // Read it after every await, preserve its current settings, and commit the
+  // parcel with its terrain so a late read cannot leave the starter polygon.
+  const scene = useScene.getState()
+  let site = findSiteNode(options.siteId)
+  const computed = sitePatchFromParcel(site, input, data, roads, undefined, extras)
+  if (!computed)
+    return {
+      ok: false,
+      error: 'parcel geometry was unusable',
+      message: 'The parcel geometry was unusable.',
+    }
+  const contours = dossier && dossierOrigin ? contourLinesFromDossier(dossier, dossierOrigin) : null
+  const patch: Partial<SiteNode> = {
+    ...computed.patch,
+    terrainContours: contours ?? undefined,
+  }
+  if (terrainRead) {
+    const { terrainSample: _previous, ...metadata } = computed.patch.metadata as Record<
+      string,
+      unknown
+    >
+    patch.terrain = terrainRead.ok ? terrainRead.terrain : undefined
+    patch.metadata = terrain ? { ...metadata, terrainSample: terrain } : metadata
+  }
+  if (site) scene.updateNode(site.id as AnyNodeId, patch as Partial<AnyNode>)
+  else {
+    site = SiteNode.parse({ id: generateId('site'), type: 'site', name: 'Site', ...patch })
+    scene.createNodes([{ node: site as AnyNode }])
+  }
+
   // A house the new lot leaves past its lines stands centred on the buildable area again, facing
   // as it did.
   let recentred = false

package/src/lib/material-swatch-style.ts

@@ -0,0 +1,24 @@
+import type { MaterialSwatch } from '@pascal-app/core'
+import type { CSSProperties } from 'react'
+
+/**
+ * The CSS that paints a material swatch: the image over its colour, and a tinted
+ * albedo multiplied by the colour, as the 3D material tints its map.
+ */
+export function materialSwatchStyle({
+  color,
+  imageUrl,
+  tinted,
+}: Pick<MaterialSwatch, 'color' | 'imageUrl'> & { tinted?: boolean }): CSSProperties {
+  return {
+    backgroundColor: color,
+    ...(imageUrl
+      ? {
+          backgroundImage: `url(${JSON.stringify(imageUrl)})`,
+          backgroundPosition: 'center',
+          backgroundSize: 'cover',
+          ...(tinted ? { backgroundBlendMode: 'multiply' } : {}),
+        }
+      : {}),
+  }
+}

package/src/lib/measurement-label.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import { measurementCentroid, pointInPolygon2D } from '@pascal-app/core'
-import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from './measurement-label'
+import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from '@pascal-app/viewer'
 
 describe('measurementPolygonLabelAnchor', () => {
   test('keeps a concave polygon label inside its visible fill', () => {

package/src/lib/measurement-parser.ts

@@ -1,6 +1,7 @@
 // Must precede the lingo import: lingo clones its kind table with
 // structuredClone while its module body evaluates. See the file's own comment.
 import './structured-clone-fallback'
+import { normalizeDecimalInput } from '@pascal-app/core'
 import { type Kind, parseQuantity, quantity } from '@pascal-app/lingo'
 
 /**
@@ -56,6 +57,8 @@ export interface ParseMeasurementOptions {
   bareUnit?: string
   /** Disambiguates gal/ton/cup families; harmless for length/angle. */
   system?: 'metric' | 'us' | 'imperial'
+  /** Locale whose decimal separator is accepted in bare values and quantities. */
+  locale?: string
 }
 
 /**
@@ -68,7 +71,7 @@ export function parseMeasurement(
   spec: LingoUnitSpec,
   options: ParseMeasurementOptions = {},
 ): number | null {
-  const result = parseQuantity(raw, {
+  const result = parseQuantity(normalizeDecimalInput(raw, options.locale), {
     kind: spec.kind,
     unit: options.bareUnit ?? spec.unitId,
     system: options.system,
@@ -105,9 +108,10 @@ export function measurementHint(
   options: MeasurementHintOptions = {},
 ): string | null {
   const trimmed = raw.trim()
-  if (!trimmed || PLAIN_NUMBER.test(trimmed)) return null
+  const normalized = normalizeDecimalInput(trimmed, options.locale)
+  if (!normalized || PLAIN_NUMBER.test(normalized)) return null
 
-  const parsed = parseMeasurement(trimmed, spec, options)
+  const parsed = parseMeasurement(normalized, spec, options)
   if (parsed === null) return null
   const stored = options.clamp ? options.clamp(parsed) : parsed
 

package/src/lib/measurements.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test } from 'bun:test'
-import { measurementHint, parseMeasurement } from '../index'
 import {
   buildMeasurementAngleArcPoints,
   cubicMetersToVolumeUnit,
@@ -11,15 +10,18 @@ import {
   getVolumeUnitLabel,
   linearControlValueToMeters,
   linearUnitToMeters,
+  metersToLinearUnit,
+  parseLinearMeasurementInput,
+  squareMetersToAreaUnit,
+} from '@pascal-app/core'
+import {
   MEASUREMENT_ACTIVE_COLOR,
   MEASUREMENT_DANGLING_COLOR,
-  MEASUREMENT_FLOORPLAN_COLOR,
   MEASUREMENT_PERSISTENT_COLOR,
-  measurementFloorplanPresentationColor,
   measurementPresentationColor,
-  metersToLinearUnit,
-  squareMetersToAreaUnit,
-} from './measurements'
+} from '@pascal-app/viewer'
+import { measurementHint, parseMeasurement } from '../index'
+import { MEASUREMENT_FLOORPLAN_COLOR, measurementFloorplanPresentationColor } from './measurements'
 
 describe('measurement presentation', () => {
   test('uses black at rest, indigo while active, and red for dangling references', () => {
@@ -129,6 +131,11 @@ describe('linear measurements', () => {
     expect(linearControlValueToMeters(3.5, 'metric')).toBe(3.5)
   })
 
+  test('parses floor-plan measurement input with the scoped locale', () => {
+    expect(parseLinearMeasurementInput('2,75', 'metric', 'fr')).toBe(2.75)
+    expect(parseLinearMeasurementInput('2,75', 'metric', 'en')).toBeNull()
+  })
+
   test('clamps numeric control input after converting to meters', () => {
     expect(linearControlValueToMeters(0.1, 'imperial', { minMeters: 0.1 })).toBe(0.1)
     expect(linearControlValueToMeters(0.3, 'imperial', { minMeters: 0.1 })).toBe(0.1)
@@ -212,4 +219,15 @@ describe('typed measurement fields', () => {
     expect(measurementHint('180cm', length)).toBe('= 1.80 m')
     expect(measurementHint('6', length)).toBeNull()
   })
+
+  test('only treats the active locale decimal separator as a plain decimal', () => {
+    const length = { kind: 'length', unitId: 'm' } as const
+
+    expect(measurementHint('1,000', length, { locale: 'en' })).not.toBeNull()
+    expect(measurementHint('-1,000', length, { locale: 'en' })).not.toBeNull()
+    expect(measurementHint('1,5', length, { locale: 'en' })).not.toBeNull()
+
+    expect(measurementHint('1,5', length, { locale: 'fr' })).toBeNull()
+    expect(parseMeasurement('2,75 m', length, { locale: 'fr' })).toBe(2.75)
+  })
 })

package/src/lib/measurements.ts

@@ -1,210 +1,8 @@
-import type { MeasurementPoint } from '@pascal-app/core'
+import { MEASUREMENT_ACTIVE_COLOR, MEASUREMENT_DANGLING_COLOR } from '@pascal-app/viewer'
 
-export type LinearUnit = 'metric' | 'imperial'
-export type MetricNotation = 'meters' | 'millimeters'
-
-export const MEASUREMENT_ACTIVE_COLOR = '#6366f1'
-export const MEASUREMENT_DANGLING_COLOR = '#dc2626'
 export const MEASUREMENT_FLOORPLAN_COLOR = '#4f46e5'
-export const MEASUREMENT_PERSISTENT_COLOR = '#111827'
-
-export function measurementPresentationColor(dangling: boolean, active: boolean): string {
-  if (dangling) return MEASUREMENT_DANGLING_COLOR
-  return active ? MEASUREMENT_ACTIVE_COLOR : MEASUREMENT_PERSISTENT_COLOR
-}
 
 export function measurementFloorplanPresentationColor(dangling: boolean, active: boolean): string {
   if (dangling) return MEASUREMENT_DANGLING_COLOR
   return active ? MEASUREMENT_ACTIVE_COLOR : MEASUREMENT_FLOORPLAN_COLOR
 }
-
-type MeasurementAngleArcOptions = {
-  radius?: number
-  sampleCount?: number
-}
-
-const ANGLE_ARC_EPSILON = 1e-9
-
-const subtractPoint = (point: MeasurementPoint, origin: MeasurementPoint): MeasurementPoint => [
-  point[0] - origin[0],
-  point[1] - origin[1],
-  point[2] - origin[2],
-]
-
-const pointLength = (point: MeasurementPoint): number => Math.hypot(...point)
-
-const scalePoint = (point: MeasurementPoint, scale: number): MeasurementPoint => [
-  point[0] * scale,
-  point[1] * scale,
-  point[2] * scale,
-]
-
-const crossPoint = (first: MeasurementPoint, second: MeasurementPoint): MeasurementPoint => [
-  first[1] * second[2] - first[2] * second[1],
-  first[2] * second[0] - first[0] * second[2],
-  first[0] * second[1] - first[1] * second[0],
-]
-
-const dotPoint = (first: MeasurementPoint, second: MeasurementPoint): number =>
-  first[0] * second[0] + first[1] * second[1] + first[2] * second[2]
-
-export function buildMeasurementAngleArcPoints(
-  start: MeasurementPoint,
-  vertex: MeasurementPoint,
-  end: MeasurementPoint,
-  options: MeasurementAngleArcOptions = {},
-): MeasurementPoint[] {
-  if (![...start, ...vertex, ...end].every(Number.isFinite)) return []
-
-  const startVector = subtractPoint(start, vertex)
-  const endVector = subtractPoint(end, vertex)
-  const startLength = pointLength(startVector)
-  const endLength = pointLength(endVector)
-  if (startLength <= ANGLE_ARC_EPSILON || endLength <= ANGLE_ARC_EPSILON) return []
-
-  const startDirection = scalePoint(startVector, 1 / startLength)
-  const endDirection = scalePoint(endVector, 1 / endLength)
-  const cosine = Math.max(-1, Math.min(1, dotPoint(startDirection, endDirection)))
-  const angle = Math.acos(cosine)
-  if (angle <= 1e-4) return []
-
-  let normal = crossPoint(startDirection, endDirection)
-  let normalLength = pointLength(normal)
-  if (normalLength <= ANGLE_ARC_EPSILON) {
-    const reference: MeasurementPoint = Math.abs(startDirection[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0]
-    normal = crossPoint(startDirection, reference)
-    normalLength = pointLength(normal)
-  }
-  if (normalLength <= ANGLE_ARC_EPSILON) return []
-  normal = scalePoint(normal, 1 / normalLength)
-  const tangent = crossPoint(normal, startDirection)
-
-  const shortestSide = Math.min(startLength, endLength)
-  const preferredRadius = options.radius ?? Math.min(Math.max(shortestSide * 0.28, 0.08), 0.75)
-  const radius = Math.min(Math.max(preferredRadius, 0), shortestSide * 0.45)
-  if (radius <= ANGLE_ARC_EPSILON) return []
-
-  const sampleCount = Math.min(
-    64,
-    Math.max(4, Math.round(options.sampleCount ?? Math.max(8, (angle / Math.PI) * 32))),
-  )
-  return Array.from({ length: sampleCount + 1 }, (_, index) => {
-    const sampleAngle = angle * (index / sampleCount)
-    const direction: MeasurementPoint = [
-      startDirection[0] * Math.cos(sampleAngle) + tangent[0] * Math.sin(sampleAngle),
-      startDirection[1] * Math.cos(sampleAngle) + tangent[1] * Math.sin(sampleAngle),
-      startDirection[2] * Math.cos(sampleAngle) + tangent[2] * Math.sin(sampleAngle),
-    ]
-    return [
-      vertex[0] + direction[0] * radius,
-      vertex[1] + direction[1] * radius,
-      vertex[2] + direction[2] * radius,
-    ]
-  })
-}
-
-const METERS_PER_FOOT = 0.3048
-const FEET_PER_METER = 1 / METERS_PER_FOOT
-
-type LinearControlValueOptions = {
-  minMeters?: number
-  maxMeters?: number
-}
-
-export function metersToLinearUnit(meters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? meters * FEET_PER_METER : meters
-}
-
-export function linearUnitToMeters(value: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? value * METERS_PER_FOOT : value
-}
-
-export function linearControlValueToMeters(
-  value: number,
-  unit: LinearUnit,
-  options: LinearControlValueOptions = {},
-): number {
-  const meters = linearUnitToMeters(value, unit)
-  const minMeters = options.minMeters ?? Number.NEGATIVE_INFINITY
-  const maxMeters = options.maxMeters ?? Number.POSITIVE_INFINITY
-
-  return Math.min(Math.max(meters, minMeters), maxMeters)
-}
-
-export function getLinearUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft' : 'm'
-}
-
-const SQUARE_FEET_PER_SQUARE_METER = FEET_PER_METER * FEET_PER_METER
-const CUBIC_FEET_PER_CUBIC_METER = SQUARE_FEET_PER_SQUARE_METER * FEET_PER_METER
-
-export function squareMetersToAreaUnit(squareMeters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? squareMeters * SQUARE_FEET_PER_SQUARE_METER : squareMeters
-}
-
-export function getAreaUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft²' : 'm²'
-}
-
-export function formatAreaLabel(
-  squareMeters: number,
-  unit: LinearUnit,
-  fractionDigits = 1,
-): string {
-  if (!Number.isFinite(squareMeters)) return '--'
-
-  return `${squareMetersToAreaUnit(squareMeters, unit).toFixed(fractionDigits)}${getAreaUnitLabel(unit)}`
-}
-
-export function cubicMetersToVolumeUnit(cubicMeters: number, unit: LinearUnit): number {
-  return unit === 'imperial' ? cubicMeters * CUBIC_FEET_PER_CUBIC_METER : cubicMeters
-}
-
-export function getVolumeUnitLabel(unit: LinearUnit): string {
-  return unit === 'imperial' ? 'ft³' : 'm³'
-}
-
-export function formatVolumeLabel(
-  cubicMeters: number,
-  unit: LinearUnit,
-  fractionDigits = 1,
-): string {
-  if (!Number.isFinite(cubicMeters)) return '--'
-
-  return `${cubicMetersToVolumeUnit(cubicMeters, unit).toFixed(fractionDigits)}${getVolumeUnitLabel(unit)}`
-}
-
-export function formatLinearMeasurement(
-  meters: number,
-  unit: LinearUnit,
-  metricNotation: MetricNotation = 'meters',
-): string {
-  if (!Number.isFinite(meters)) return '--'
-
-  const absoluteMeters = Math.abs(meters)
-
-  if (unit === 'imperial') {
-    const feet = metersToLinearUnit(absoluteMeters, unit)
-    let wholeFeet = Math.floor(feet)
-    let inches = Math.round((feet - wholeFeet) * 12)
-    if (inches === 12) {
-      wholeFeet += 1
-      inches = 0
-    }
-
-    const sign = meters < 0 && (wholeFeet !== 0 || inches !== 0) ? '-' : ''
-
-    return `${sign}${wholeFeet}'${inches}"`
-  }
-
-  if (metricNotation === 'millimeters') {
-    const roundedMillimeters = Math.round(absoluteMeters * 1000)
-    const sign = meters < 0 && roundedMillimeters !== 0 ? '-' : ''
-    return `${sign}${roundedMillimeters}mm`
-  }
-
-  const roundedMeters = Number.parseFloat(absoluteMeters.toFixed(2))
-  const sign = meters < 0 && roundedMeters !== 0 ? '-' : ''
-
-  return `${sign}${roundedMeters}m`
-}

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

@@ -169,7 +169,9 @@ describe('mezzanine selection', () => {
     expect(gesture(hostId, ROOM_MOVE_DRAG_LABEL)).toBeNull()
     expect(gesture(mezzanineId, 'height')).toBeNull()
     expect(mezzanineGesture(null, nodes())).toBeNull()
-    expect(MEZZANINE_GESTURE_HINTS.move[0]!.label).toBe('Place inside the room')
+    expect(MEZZANINE_GESTURE_HINTS.move[0]!.label).toMatchObject({
+      message: 'Place inside the room',
+    })
   })
 
   test('the delete dialog speaks of the mezzanine, and of its items only when it has some', () => {

package/src/lib/node-action-movement.test.tsx

@@ -0,0 +1,115 @@
+import { beforeAll, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type AnyNodeId,
+  isMoveLocked,
+  isNodeDuplicable,
+  nodeRegistry,
+  registerNode,
+  useScene,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import { duplicateNodeAndPickUp } from '../components/editor/duplicate-node'
+import { classifyParticipant } from '../components/editor/group-transform-shared'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import { canDirectMoveNode } from './direct-manipulation'
+import { createEditorApi } from './editor-api'
+import { registryMoveDisabled } from './node-action-movement'
+import { copySelectedNodesToEditorClipboard } from './scene-clipboard'
+
+// Mirrors a lean-to post: a kind-level 2D mover plus per-node move and duplicate locks.
+const KIND = 'move-lock-test'
+
+beforeAll(() => {
+  if (nodeRegistry.has(KIND)) return
+  registerNode({
+    kind: KIND,
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal(KIND) }) as never,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: {
+      movable: {
+        axes: ['x', 'z'],
+        gridSnap: true,
+        override: ({ node }) =>
+          (node as { metadata?: { locked?: boolean } }).metadata?.locked
+            ? { axes: [], gridSnap: false }
+            : null,
+      },
+      duplicable: {
+        allow: ({ node }) => !(node as { metadata?: { locked?: boolean } }).metadata?.locked,
+      },
+    },
+    floorplanMoveTarget: () => ({
+      affectedIds: [],
+      apply() {},
+      canCommit: () => false,
+      commit() {},
+    }),
+    renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
+  } as AnyNodeDefinition)
+})
+
+function node(locked: boolean) {
+  return {
+    id: locked ? 'move_lock_locked' : 'move_lock_free',
+    type: KIND,
+    parentId: 'level_move_lock',
+    position: [1, 0, 2],
+    rotation: 0,
+    metadata: locked ? { locked: true } : {},
+  } as unknown as AnyNode
+}
+
+test('a per-node override lock outranks the kind-level 2D mover', () => {
+  expect(isMoveLocked(node(true))).toBe(true)
+  expect(isMoveLocked(node(false))).toBe(false)
+  expect(registryMoveDisabled(node(true))).toBe(true)
+  expect(registryMoveDisabled(node(false))).toBe(false)
+  expect(canDirectMoveNode(node(true))).toBe(false)
+})
+
+test('group pick-up leaves a locked node behind', () => {
+  const locked = node(true)
+  const free = node(false)
+  const nodes = { [locked.id]: locked, [free.id]: free }
+  expect(classifyParticipant(locked, 'level_move_lock', nodes)).toBeNull()
+  expect(classifyParticipant(free, 'level_move_lock', nodes)).toBe('scalar')
+})
+
+test('every moving-node entry refuses a locked node', () => {
+  const api = createEditorApi()
+  useEditor.getState().setMovingNode(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  api.engageMoveDrag(node(true))
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(useEditor.getState().placementDragMode).toBe(false)
+  api.engageMove(node(false))
+  expect(useInteractionScope.getState().scope.kind).toBe('moving')
+  useEditor.getState().setMovingNode(null)
+})
+
+test('a locked node cannot be duplicated or copied', () => {
+  const level = {
+    id: 'level_move_lock',
+    type: 'level',
+    parentId: null,
+    children: ['move_lock_locked', 'move_lock_free'],
+  } as unknown as AnyNode
+  const locked = node(true)
+  const free = node(false)
+  useScene.setState({
+    nodes: { [level.id]: level, [locked.id]: locked, [free.id]: free } as never,
+    rootNodeIds: [level.id as AnyNodeId],
+  })
+  expect(isNodeDuplicable(locked)).toBe(false)
+  expect(isNodeDuplicable(free)).toBe(true)
+  duplicateNodeAndPickUp(locked)
+  expect(Object.keys(useScene.getState().nodes)).toHaveLength(3)
+  expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  expect(copySelectedNodesToEditorClipboard([locked.id as AnyNodeId])).toBe(false)
+  expect(copySelectedNodesToEditorClipboard([free.id as AnyNodeId])).toBe(true)
+})

package/src/lib/node-action-movement.ts

@@ -4,12 +4,14 @@ import {
   cloneNodesInto,
   collectSubtree,
   isMovable,
+  isMoveLocked,
   nodeRegistry,
   useScene,
 } from '@pascal-app/core'
 import { copyCreateOps } from './fresh-planar-placement'
 
 export function registryMoveDisabled(node: AnyNode): boolean {
+  if (isMoveLocked(node)) return true
   const def = nodeRegistry.get(node.type)
   return Boolean(
     def?.capabilities.movable &&