@pascal-app/editor 1.0.0 → 1.0.3

package/src/lib/glb-export.ts

@@ -7,6 +7,7 @@ import {
   findLevelAncestorId,
   type GeometryContext,
   getLevelDisplayName,
+  hidesDescendants,
   isNodeKindEnabled,
   isOperationDoorType,
   itemClipRegistry,
@@ -35,9 +36,13 @@ import {
   type GLTFExporterPlugin,
   type GLTFWriter,
 } from 'three/examples/jsm/exporters/GLTFExporter.js'
-import * as WebGPUTextureUtils from 'three/examples/jsm/utils/WebGPUTextureUtils.js'
+import { createExportTextureUtils, type ExportTextureUtils } from './export-texture-utils'
+import { cloneExportUserData } from './export-user-data'
 import {
+  type CompressedTextureDecompressor,
+  decompressCanonicalNormalMaps,
   disposeExportResources,
+  GLASS_OPACITY_USERDATA,
   normalizePortableScene,
   normalizeViewerArtifactMaterials,
 } from './portable-export'
@@ -69,12 +74,61 @@ export type GlbExportOptions = {
   excludedNodeTypes?: readonly string[]
   /** Selected static viewer-presentation contributions; omitted means none. */
   includedPresentationIds?: readonly string[]
-  /** Portable downloads are static; the baked viewer retains internal clips. */
+  /** Portable materials/geometry normalisation vs the baked viewer artifact. */
   purpose?: 'portable' | 'viewer'
+  /**
+   * Door/window open clips. Defaults to `keep` for the viewer bake and for GLB
+   * downloads (Blender turns them into actions); USDZ and print pass `none`
+   * because those formats freeze geometry and cannot play them.
+   */
+  animations?: 'keep' | 'none'
   /** Called for actual lossy portable conversions discovered during preparation. */
   onWarning?: (warning: string) => void
   /** Reject retained node kinds whose export geometry can only be baked asynchronously. */
   requireSynchronousBake?: boolean
+  /** GPU decompressor for compressed normal maps that must be baked; defaults to `textureUtils`. */
+  decompressTexture?: CompressedTextureDecompressor
+  /**
+   * Shared GPU decompressor for every compressed texture in the export. The
+   * export entry points create one per export and dispose it; supplying your
+   * own keeps ownership with you.
+   */
+  textureUtils?: ExportTextureUtils
+  /**
+   * Wall-clock deadline for the whole export (preparation and serialisation),
+   * after which it rejects instead of leaving the caller waiting. Defaults to
+   * `DEFAULT_MODEL_EXPORT_TIMEOUT_MS`; `Infinity` disables it.
+   */
+  timeoutMs?: number
+}
+
+export const DEFAULT_MODEL_EXPORT_TIMEOUT_MS = 180_000
+
+/**
+ * three's exporters finish inside `FileReader.onloadend` and `canvas.toBlob`
+ * callbacks that carry no error path: a failed read or a callback the browser
+ * never invokes calls neither `onDone` nor `onError`, so without a deadline the
+ * returned promise stays pending forever and the export UI is stuck.
+ */
+export function withExportDeadline<Result>(
+  promise: Promise<Result>,
+  timeoutMs: number,
+  format: string,
+  onTimeout?: () => void,
+): Promise<Result> {
+  if (!Number.isFinite(timeoutMs)) return promise
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const deadline = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => {
+      onTimeout?.()
+      reject(
+        new Error(
+          `${format} export timed out after ${Math.max(1, Math.round(timeoutMs / 1000))} s. Try again with “Visible nodes only” to shrink the scene, or reload the page if it keeps failing.`,
+        ),
+      )
+    }, timeoutMs)
+  })
+  return Promise.race([promise, deadline]).finally(() => clearTimeout(timer))
 }
 
 /** Resolve after the next couple of animation frames, giving React/R3F time to
@@ -144,15 +198,43 @@ export async function exportSceneToGlb(
   options: GlbExportOptions = {},
 ): Promise<ArrayBuffer> {
   const textureMode = options.textures ?? 'embed'
-  const prepared = await preparePortableSceneFromViewer(sceneGroup, nodes, options)
-  for (const warning of prepared.warnings) options.onWarning?.(warning)
+  const textureUtils = options.textureUtils ?? createExportTextureUtils()
+  // Preparation awaits plugin bake hooks and presentation builders, so the
+  // deadline has to cover it as well as the serialisation.
+  const preparation = preparePortableSceneFromViewer(sceneGroup, nodes, {
+    ...options,
+    textureUtils,
+    animations: options.animations ?? 'keep',
+  })
+  // Assigned inside the raced closure, so a plain `let` narrows to `never` in
+  // the `finally`.
+  const run: { prepared: GlbExport | null; abandoned: boolean } = {
+    prepared: null,
+    abandoned: false,
+  }
   try {
-    return await serializePreparedSceneToGlb(prepared, {
-      textures: textureMode,
-      onlyVisible: options.onlyVisible,
-    })
+    return await withExportDeadline(
+      (async () => {
+        run.prepared = await preparation
+        // The race has already rejected; don't serialise a file nobody will get.
+        if (run.abandoned) throw new Error('GLB export abandoned')
+        for (const warning of run.prepared.warnings) options.onWarning?.(warning)
+        return serializePreparedSceneToGlb(run.prepared, {
+          textures: textureMode,
+          onlyVisible: options.onlyVisible,
+          textureUtils,
+        })
+      })(),
+      options.timeoutMs ?? DEFAULT_MODEL_EXPORT_TIMEOUT_MS,
+      'GLB',
+      () => {
+        run.abandoned = true
+      },
+    )
   } finally {
-    prepared.dispose()
+    if (run.prepared) run.prepared.dispose()
+    else preparation.then((late) => late.dispose()).catch(() => {})
+    if (!options.textureUtils) await textureUtils.dispose()
   }
 }
 /**
@@ -179,24 +261,30 @@ export async function preparePortableSceneFromViewer(
   return completeSceneExportPreparation(preparation)
 }
 
+/** Serialise a prepared scene; callers own the deadline (see `exportSceneToGlb`). */
 export function serializePreparedSceneToGlb(
   prepared: GlbExport,
-  options: Pick<GlbExportOptions, 'textures' | 'onlyVisible'> = {},
+  options: Pick<GlbExportOptions, 'textures' | 'onlyVisible'> & {
+    textureUtils: ExportTextureUtils
+  },
 ): Promise<ArrayBuffer> {
   const exporter = new GLTFExporter()
   if ((options.textures ?? 'embed') === 'reference') {
     exporter.register(textureReferencePlugin)
   }
-  exporter.setTextureUtils(WebGPUTextureUtils)
+  exporter.setTextureUtils(options.textureUtils)
 
   return new Promise<ArrayBuffer>((resolve, reject) => {
     exporter.parse(
       prepared.scene,
       (gltf) => {
-        resolve(gltf as ArrayBuffer)
+        // A failed final FileReader hands GLTFExporter's onDone `null`, which
+        // `new Blob([null])` would happily turn into a four-byte download.
+        if (gltf instanceof ArrayBuffer) resolve(gltf)
+        else reject(new Error('GLB export produced no data'))
       },
       (error) => {
-        reject(error)
+        reject(error instanceof Error ? error : new Error(String(error)))
       },
       {
         binary: true,
@@ -342,22 +430,47 @@ function startSceneExportPreparation(
   }
 }
 
+/** Own a throwaway decompressor only when the caller supplied neither form. */
+function resolveNormalMapDecompressor(options: GlbExportOptions): {
+  decompress: CompressedTextureDecompressor
+  dispose: () => Promise<void>
+} {
+  if (options.decompressTexture) {
+    return { decompress: options.decompressTexture, dispose: async () => {} }
+  }
+  const utils = options.textureUtils ?? createExportTextureUtils()
+  return {
+    decompress: (texture) => utils.decompress(texture),
+    dispose: options.textureUtils ? async () => {} : () => utils.dispose(),
+  }
+}
+
 async function completeSceneExportPreparation(
   preparation: SceneExportPreparation,
 ): Promise<GlbExport> {
+  const decompressor = resolveNormalMapDecompressor(preparation.options)
   try {
     await replaceBakeGeometryAsync(preparation)
     await appendSelectedPresentations(preparation)
     const prepared = finishSceneExportPreparation(preparation)
+    const { options } = preparation
+    const byReference = (options.textures ?? 'embed') === 'reference'
+    const normalizeOptions = {
+      preserveNormalMap: (texture: THREE.Texture) =>
+        byReference && getPascalTextureRef(texture) !== null,
+    }
+    await decompressCanonicalNormalMaps(prepared.scene, decompressor.decompress, normalizeOptions)
     prepared.warnings.push(
-      ...(preparation.options.purpose === 'viewer'
-        ? normalizeViewerArtifactMaterials(prepared.scene)
-        : normalizePortableScene(prepared.scene)),
+      ...(options.purpose === 'viewer'
+        ? normalizeViewerArtifactMaterials(prepared.scene, normalizeOptions)
+        : normalizePortableScene(prepared.scene, normalizeOptions)),
     )
     return prepared
   } catch (error) {
     disposeExportResources(preparation.scene)
     throw error
+  } finally {
+    await decompressor.dispose()
   }
 }
 
@@ -374,10 +487,12 @@ function finishSceneExportPreparation(preparation: SceneExportPreparation): GlbE
   convertMaterials(scene, options.textures ?? 'embed', options.purpose ?? 'viewer')
 
   const retainedCloneByOriginal = retainedClones(scene, cloneByOriginal)
-  const animation =
-    options.purpose === 'viewer'
-      ? bakeAnimationClips(retainedCloneByOriginal, nodes, registryEntries)
-      : { clips: [], clipNamesByNode: new Map<string, string[]>() }
+  const keepClips = options.animations
+    ? options.animations === 'keep'
+    : options.purpose === 'viewer'
+  const animation = keepClips
+    ? bakeAnimationClips(retainedCloneByOriginal, nodes, registryEntries)
+    : { clips: [], clipNamesByNode: new Map<string, string[]>() }
   stampIdentity(scene, retainedCloneByOriginal, nodes, animation.clipNamesByNode, registryEntries)
 
   let disposed = false
@@ -495,7 +610,7 @@ function ownBorrowedPresentationTextures(root: THREE.Object3D): void {
         let ownedTexture = ownedTextures.get(sourceTexture)
         if (!ownedTexture) {
           ownedTexture = sourceTexture.clone()
-          ownedTexture.userData = structuredClone(sourceTexture.userData)
+          ownedTexture.userData = cloneExportUserData(sourceTexture.userData)
           ownedTexture.needsUpdate = true
           ownedTextures.set(sourceTexture, ownedTexture)
         }
@@ -601,16 +716,6 @@ function pruneHiddenSceneNodes(
   registryEntries: readonly RegistryEntry[],
 ) {
   const visibility = new Map<string, boolean>()
-  const declaredSiteParents = new Map<string, string>()
-  for (const node of Object.values(nodes)) {
-    if (node.type !== 'site' || !('children' in node) || !Array.isArray(node.children)) continue
-    for (const childId of node.children) {
-      const child = nodes[childId]
-      if (child && !child.parentId && !declaredSiteParents.has(childId)) {
-        declaredSiteParents.set(childId, node.id)
-      }
-    }
-  }
 
   const isVisible = (id: string, path: Set<string>): boolean => {
     const cached = visibility.get(id)
@@ -622,8 +727,9 @@ function pruneHiddenSceneNodes(
       visibility.set(id, false)
       return false
     }
-    const parentId = node.parentId || declaredSiteParents.get(id)
-    if (!parentId || path.has(id)) {
+    const parentId = node.parentId
+    const parent = parentId ? nodes[parentId] : undefined
+    if (!parentId || path.has(id) || (parent && !hidesDescendants(parent))) {
       visibility.set(id, true)
       return true
     }
@@ -635,12 +741,33 @@ function pruneHiddenSceneNodes(
     return visible
   }
 
+  const nodeClones = new Set<THREE.Object3D>()
+  for (const [, original] of registryEntries) {
+    const clone = cloneByOriginal.get(original)
+    if (clone) nodeClones.add(clone)
+  }
+
   for (const [id, original] of registryEntries) {
     if (isVisible(id, new Set())) continue
-    cloneByOriginal.get(original)?.removeFromParent()
+    const clone = cloneByOriginal.get(original)
+    if (!clone) continue
+    const node = nodes[id]
+    if (!node || hidesDescendants(node)) {
+      clone.removeFromParent()
+      continue
+    }
+    // Drop the hidden Site's own ground fill and boundary; keep what it hosts.
+    for (const child of [...clone.children]) {
+      if (!hostsSceneNode(child, nodeClones)) child.removeFromParent()
+    }
   }
 }
 
+function hostsSceneNode(object: THREE.Object3D, nodeClones: Set<THREE.Object3D>): boolean {
+  if (nodeClones.has(object)) return true
+  return object.children.some((child) => hostsSceneNode(child, nodeClones))
+}
+
 function retainedClones(
   root: THREE.Object3D,
   cloneByOriginal: Map<THREE.Object3D, THREE.Object3D>,
@@ -670,7 +797,7 @@ function cloneSceneForExport(
   if (excludedObjects.has(source)) return new THREE.Group()
 
   const clone = source.clone(false)
-  clone.userData = structuredClone(source.userData)
+  clone.userData = cloneExportUserData(source.userData)
   const renderable = source as THREE.Mesh
   const renderableClone = clone as THREE.Mesh
   if (renderable.geometry) {
@@ -693,7 +820,7 @@ function cloneSceneForExport(
         let textureClone = cache.textures.get(texture)
         if (!textureClone) {
           textureClone = texture.clone()
-          textureClone.userData = structuredClone(texture.userData)
+          textureClone.userData = cloneExportUserData(texture.userData)
           textureClone.needsUpdate = true
           cache.textures.set(texture, textureClone)
         }
@@ -1047,7 +1174,8 @@ function convertMaterial(
   if (cached) return cached
 
   const src = material as THREE.Material & Record<string, unknown>
-  const target = new THREE.MeshStandardMaterial()
+  const glass = purpose === 'portable' && isPortableGlass(material)
+  const target = glass ? new THREE.MeshPhysicalMaterial() : new THREE.MeshStandardMaterial()
 
   target.name = material.name
   if (src.color instanceof THREE.Color) target.color.copy(src.color)
@@ -1083,12 +1211,44 @@ function convertMaterial(
     }
   }
 
+  if (glass) applyPortableGlass(target as THREE.MeshPhysicalMaterial, material)
   if (textureMode === 'reference') replaceReferencedTextures(target, placeholderCache)
 
   cache.set(material, target)
   return target
 }
 
+/** Mirrors the viewer's own rule (`maybeApplyGlassFresnel`): an untextured
+ * see-through surface below this opacity is glass, not tinted plastic. */
+const GLASS_OPACITY_THRESHOLD = 0.6
+
+function isPortableGlass(material: THREE.Material): boolean {
+  const src = material as THREE.Material & Record<string, unknown>
+  return (
+    material.transparent &&
+    material.opacity < GLASS_OPACITY_THRESHOLD &&
+    !(src.map instanceof THREE.Texture)
+  )
+}
+
+/**
+ * The viewer sells glass with a fresnel-driven opacity node, which glTF cannot
+ * carry; a plain alpha blend lands in every other tool as a blue film. Real
+ * transmission (KHR_materials_transmission + ior) is what Blender, Unity and
+ * Unreal all render as glass. The authored opacity becomes the tint strength.
+ */
+function applyPortableGlass(target: THREE.MeshPhysicalMaterial, source: THREE.Material) {
+  target.color.lerp(new THREE.Color(0xffffff), 1 - source.opacity)
+  target.transmission = 1
+  target.ior = 1.5
+  target.roughness = Math.min(target.roughness, 0.15)
+  target.metalness = 0
+  target.transparent = false
+  target.opacity = 1
+  target.depthWrite = true
+  target.userData[GLASS_OPACITY_USERDATA] = source.opacity
+}
+
 function replaceReferencedTextures(
   material: THREE.Material,
   placeholderCache: Map<THREE.Texture, THREE.Texture>,

package/src/lib/grid-frame.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from 'bun:test'
+import { Group, Vector3 } from 'three'
+import { gridLocalNormal, gridLocalPoint } from './grid-frame'
+
+test('grid floor and cursor stay in model coordinates after God-view pan, scale and yaw', () => {
+  const root = new Group()
+  root.position.set(2, 4, -3)
+  root.rotation.y = Math.PI / 3
+  root.scale.setScalar(0.2)
+  root.updateMatrixWorld(true)
+  const local = new Vector3(3, 2.5, 7)
+  const world = root.localToWorld(local.clone())
+  expect(gridLocalPoint(root, world, new Vector3()).distanceTo(local)).toBeLessThan(1e-8)
+  const normal = new Vector3(1, 0, 0).transformDirection(root.matrixWorld)
+  expect(
+    gridLocalNormal(root, normal, new Vector3()).distanceTo(new Vector3(1, 0, 0)),
+  ).toBeLessThan(1e-8)
+  expect(world.distanceTo(local)).toBeGreaterThan(1)
+})

package/src/lib/grid-frame.ts

@@ -0,0 +1,18 @@
+import type { Object3D, Vector3 } from 'three'
+
+// Placement surfaces are world-space; the grid lives under the scalable XR
+// scene root. Keep its lattice and reveal in that root's model coordinates.
+export function gridLocalPoint(parent: Object3D | null, world: Vector3, target: Vector3) {
+  target.copy(world)
+  if (parent) {
+    parent.updateWorldMatrix(true, false)
+    parent.worldToLocal(target)
+  }
+  return target
+}
+
+export function gridLocalNormal(parent: Object3D | null, normal: Vector3, target: Vector3) {
+  target.copy(normal)
+  if (parent) target.transformDirection(parent.matrixWorld.clone().invert())
+  return target
+}

package/src/lib/interaction/scope.ts

@@ -19,7 +19,15 @@ export type ReshapeDriver = 'tool' | 'floorplan'
 // node, one in-flight reshape. Grouping them as sub-states of `reshaping`
 // (rather than four sibling scopes) keeps the union small while still making
 // "curving and hole-editing at once" unrepresentable.
-export type ReshapeKind = 'curve' | 'hole' | 'endpoint' | 'boundary' | 'control-point' | 'tangent'
+export type ReshapeKind =
+  | 'curve'
+  | 'hole'
+  | 'endpoint'
+  | 'boundary'
+  | 'control-point'
+  | 'tangent'
+  // A kind's own reshape (wall 'split'): mounted from `def.affordanceTools[reshape]`.
+  | 'split'
 
 export type InteractionScope =
   | { kind: 'idle' }

package/src/lib/keyboard-pan.test.ts

@@ -0,0 +1,62 @@
+import { afterAll, beforeAll, expect, test } from 'bun:test'
+import {
+  acceptsKeyboardPan,
+  clearKeyboardPanKeys,
+  hasKeyboardPanInput,
+  isKeyboardPanKey,
+  type KeyboardPanState,
+  keyboardPanDirection,
+  keyboardPanSpeed,
+  setKeyboardPanKey,
+} from './keyboard-pan'
+
+const idle = (): KeyboardPanState => ({
+  forward: false,
+  backward: false,
+  left: false,
+  right: false,
+})
+const key = (init: Partial<KeyboardEvent>) => ({ target: null, ...init }) as KeyboardEvent
+
+// No DOM in this runner: stand in for the element classes the editable check reads.
+const DOM_CLASSES = ['HTMLElement', 'HTMLInputElement', 'HTMLTextAreaElement', 'HTMLSelectElement']
+const stubbed: string[] = []
+beforeAll(() => {
+  const scope = globalThis as Record<string, unknown>
+  for (const name of DOM_CLASSES) {
+    if (scope[name]) continue
+    scope[name] = class {}
+    stubbed.push(name)
+  }
+})
+afterAll(() => {
+  for (const name of stubbed) delete (globalThis as Record<string, unknown>)[name]
+})
+
+test('physical WASD keys drive a screen-space direction; letters on other layouts do not', () => {
+  const state = idle()
+  expect(isKeyboardPanKey('KeyZ')).toBe(false)
+  expect(setKeyboardPanKey(state, 'KeyW', true)).toBe(true)
+  expect(setKeyboardPanKey(state, 'KeyW', true)).toBe(false)
+  setKeyboardPanKey(state, 'KeyD', true)
+  expect(keyboardPanDirection(state)).toEqual({ horizontal: 1, vertical: 1 })
+  setKeyboardPanKey(state, 'KeyA', true)
+  expect(keyboardPanDirection(state)).toEqual({ horizontal: 0, vertical: 1 })
+  clearKeyboardPanKeys(state)
+  expect(hasKeyboardPanInput(state)).toBe(false)
+})
+
+test('modifier chords stay shortcuts, and typing in a field never pans', () => {
+  expect(acceptsKeyboardPan(key({}))).toBe(true)
+  for (const modifier of ['metaKey', 'ctrlKey', 'altKey'] as const)
+    expect(acceptsKeyboardPan(key({ [modifier]: true }))).toBe(false)
+  const Input = (globalThis as unknown as { HTMLInputElement: new () => EventTarget })
+    .HTMLInputElement
+  expect(acceptsKeyboardPan(key({ target: new Input() }))).toBe(false)
+})
+
+test('speed scales with the visible width within fixed bounds', () => {
+  expect(keyboardPanSpeed(0)).toBe(2)
+  expect(keyboardPanSpeed(20)).toBeCloseTo(13)
+  expect(keyboardPanSpeed(1000)).toBe(55)
+})

package/src/lib/keyboard-pan.ts

@@ -0,0 +1,89 @@
+// WASD navigation shared by the 3D camera and the 2D floor plan, so both views
+// move the same way. Keys match by physical position (`event.code`): the
+// cluster stays under the left hand on any layout (Z/Q/S/D on AZERTY).
+
+export type KeyboardPanState = {
+  forward: boolean
+  backward: boolean
+  left: boolean
+  right: boolean
+}
+
+const KEYBOARD_PAN_VIEW_WIDTH_PER_SECOND = 0.65
+const KEYBOARD_PAN_MIN_SPEED = 2
+const KEYBOARD_PAN_MAX_SPEED = 55
+
+export function isEditableKeyboardTarget(target: EventTarget | null) {
+  return (
+    target instanceof HTMLInputElement ||
+    target instanceof HTMLTextAreaElement ||
+    target instanceof HTMLSelectElement ||
+    (target instanceof HTMLElement && target.isContentEditable)
+  )
+}
+
+export function setKeyboardPanKey(
+  state: KeyboardPanState,
+  code: string,
+  pressed: boolean,
+): boolean {
+  if (code === 'KeyW') {
+    const changed = state.forward !== pressed
+    state.forward = pressed
+    return changed
+  }
+  if (code === 'KeyS') {
+    const changed = state.backward !== pressed
+    state.backward = pressed
+    return changed
+  }
+  if (code === 'KeyA') {
+    const changed = state.left !== pressed
+    state.left = pressed
+    return changed
+  }
+  if (code === 'KeyD') {
+    const changed = state.right !== pressed
+    state.right = pressed
+    return changed
+  }
+  return false
+}
+
+export function isKeyboardPanKey(code: string): boolean {
+  return code === 'KeyW' || code === 'KeyA' || code === 'KeyS' || code === 'KeyD'
+}
+
+export function hasKeyboardPanInput(state: KeyboardPanState): boolean {
+  return state.forward || state.backward || state.left || state.right
+}
+
+export function clearKeyboardPanKeys(state: KeyboardPanState) {
+  state.forward = false
+  state.backward = false
+  state.left = false
+  state.right = false
+}
+
+/** Pan keys are ignored with a modifier held (shortcuts) or while typing. */
+export function acceptsKeyboardPan(event: KeyboardEvent) {
+  return (
+    !(event.metaKey || event.ctrlKey || event.altKey) && !isEditableKeyboardTarget(event.target)
+  )
+}
+
+/** Screen-space direction: `horizontal` +1 is right, `vertical` +1 is forward (up). */
+export function keyboardPanDirection(state: KeyboardPanState) {
+  return {
+    horizontal: (state.right ? 1 : 0) - (state.left ? 1 : 0),
+    vertical: (state.forward ? 1 : 0) - (state.backward ? 1 : 0),
+  }
+}
+
+/** World units per second for a view `viewWidth` wide. */
+export function keyboardPanSpeed(viewWidth: number) {
+  return Math.min(
+    Math.max(viewWidth * KEYBOARD_PAN_VIEW_WIDTH_PER_SECOND, KEYBOARD_PAN_MIN_SPEED),
+    KEYBOARD_PAN_MAX_SPEED,
+  )
+}

package/src/lib/level-duplication.test.ts

@@ -5,7 +5,9 @@ import {
   BuildingNode,
   LevelNode,
   SpawnNode,
+  UnitNode,
   WallNode,
+  ZoneNode,
 } from '@pascal-app/core/schema'
 import { buildLevelDuplicateCreateOps } from './level-duplication'
 
@@ -69,3 +71,74 @@ describe('buildLevelDuplicateCreateOps', () => {
     expect(copiedLevel?.children).toEqual([])
   })
 })
+
+describe('unit duplication', () => {
+  for (const preset of [
+    'everything',
+    'structure',
+    'structure-materials',
+    'structure-furniture',
+  ] as const) {
+    test(`duplicates only units wholly on the source level with ${preset}`, () => {
+      const building = BuildingNode.parse({})
+      const level = LevelNode.parse({ parentId: building.id, level: 0 })
+      const upper = LevelNode.parse({ parentId: building.id, level: 1 })
+      const kitchen = ZoneNode.parse({ parentId: level.id, name: 'Kitchen', polygon: [] })
+      const living = ZoneNode.parse({ parentId: level.id, name: 'Living', polygon: [] })
+      const bedroom = ZoneNode.parse({ parentId: upper.id, name: 'Bedroom', polygon: [] })
+      const single = UnitNode.parse({
+        parentId: building.id,
+        name: 'Suite',
+        kind: 'hotel-room',
+        color: '#123456',
+        members: [kitchen.id, living.id],
+      })
+      const duplex = UnitNode.parse({
+        parentId: building.id,
+        name: 'Duplex',
+        members: [living.id, bedroom.id],
+      })
+      const empty = UnitNode.parse({ parentId: building.id })
+      const dangling = UnitNode.parse({
+        parentId: building.id,
+        members: [kitchen.id, 'zone_missing'],
+      })
+      level.children = [kitchen.id, living.id]
+      upper.children = [bedroom.id]
+      building.children = [level.id, upper.id, single.id, duplex.id, empty.id, dangling.id]
+      const nodes: Record<AnyNodeId, AnyNode> = Object.fromEntries(
+        [building, level, upper, kitchen, living, bedroom, single, duplex, empty, dangling].map(
+          (node) => [node.id, node],
+        ),
+      )
+      const before = structuredClone(nodes)
+      const { createOps, newLevelId, shiftedLevels } = buildLevelDuplicateCreateOps({
+        nodes,
+        level,
+        levels: [level, upper],
+        preset,
+      })
+      const unitOps = createOps.filter((op) => op.node.type === 'unit')
+      expect(unitOps).toHaveLength(1)
+      const op = unitOps[0]!
+      expect(op.parentId).toBe(building.id)
+      expect(op.node.type).toBe('unit')
+      if (op.node.type !== 'unit') return
+      expect(op.node.id).not.toBe(single.id)
+      expect(op.node.name).toBe('Suite copy')
+      expect(op.node.kind).toBe(single.kind)
+      expect(op.node.color).toBe(single.color)
+      expect(op.node.parentId).toBe(building.id)
+      expect(op.node.members).toEqual(
+        createOps.flatMap((entry) => (entry.node.type === 'zone' ? [entry.node.id] : [])),
+      )
+      expect(
+        createOps
+          .filter((entry) => entry.node.type === 'zone')
+          .every((entry) => entry.parentId === newLevelId),
+      ).toBe(true)
+      expect(shiftedLevels).toEqual([{ id: upper.id, level: 2 }])
+      expect(nodes).toEqual(before)
+    })
+  }
+})