@pascal-app/editor 1.0.0 → 1.0.1

package/src/lib/glb-export.test.ts

@@ -27,6 +27,7 @@ import {
   prepareSceneForExportAsync,
   writeTextureReferenceExtras,
 } from './glb-export'
+import { createUsdzScene } from './portable-export'
 
 // The reference module reads the storage origin lazily on first use, so
 // setting the env here (before any validation call) pins it for the file.
@@ -99,6 +100,29 @@ describe('prepareSceneForExport', () => {
     expect(material.color.getHexString()).toBe('cc3300')
   })
 
+  test('clones userData that holds runtime resources and functions', () => {
+    const root = new THREE.Group()
+    root.name = 'scene-renderer'
+    const effectMaterial = new THREE.MeshStandardMaterial()
+    effectMaterial.addEventListener('dispose', () => {})
+    const pool = meshWithNodeMaterial(nodeMaterial())
+    pool.userData = { waterEffect: { material: effectMaterial, onFrame: () => {} } }
+    const overlay = meshWithNodeMaterial(nodeMaterial())
+    overlay.userData = { pascalExport: 'strip', mesh: pool }
+    root.add(pool, overlay)
+    expect(() => structuredClone(pool.userData)).toThrow()
+
+    const { scene } = prepareSceneForExport(root, {})
+
+    const meshes: THREE.Mesh[] = []
+    scene.traverse((object) => {
+      if ((object as THREE.Mesh).isMesh) meshes.push(object as THREE.Mesh)
+    })
+    expect(meshes).toHaveLength(1)
+    expect(meshes[0]?.userData.waterEffect).toBeUndefined()
+    expect(pool.userData.waterEffect.material).toBe(effectMaterial)
+  })
+
   test('replaces only the cloned registered subtree with bake-only geometry', () => {
     const restoreRegistry = nodeRegistry._snapshot()
     try {
@@ -1685,6 +1709,21 @@ async function withCanvasCapture(
           putImageData: (image: ImageData) => {
             pixelsByCanvas.set(canvas, new Uint8ClampedArray(image.data))
           },
+          fillRect: (_x: number, _y: number, width: number, height: number) => {
+            pixelsByCanvas.set(canvas, new Uint8ClampedArray(width * height * 4).fill(255))
+          },
+          drawImage: (image: HTMLCanvasElement) => {
+            const pixels = pixelsByCanvas.get(image)
+            if (!pixels) throw new Error('Source canvas has no captured pixels')
+            pixelsByCanvas.set(canvas, new Uint8ClampedArray(pixels))
+          },
+          getImageData: (_x: number, _y: number, width: number, height: number) =>
+            ({
+              colorSpace: 'srgb',
+              data: pixelsByCanvas.get(canvas) ?? new Uint8ClampedArray(width * height * 4),
+              height,
+              width,
+            }) as ImageData,
         }),
       } as unknown as HTMLCanvasElement
       return canvas
@@ -1702,3 +1741,170 @@ async function withCanvasCapture(
     else delete globals.document
   }
 }
+
+describe('normal maps in async export preparation', () => {
+  test('decompresses a compressed normal map through the provided decompressor before baking its scale', async () => {
+    await withCanvasCapture(async () => {
+      const root = new THREE.Group()
+      const compressed = new THREE.CompressedTexture([], 2, 2)
+      compressed.name = 'NormalGL_3a132c5f'
+      const material = nodeMaterial({ normalMap: compressed }) as THREE.MeshStandardMaterial
+      material.normalScale.set(0.5, 0.5)
+      root.add(meshWithNodeMaterial(material))
+      let calls = 0
+
+      const prepared = await prepareSceneForExportAsync(
+        root,
+        {},
+        {
+          decompressTexture: async (texture) => {
+            calls += 1
+            expect(texture.name).toBe('NormalGL_3a132c5f')
+            return new THREE.DataTexture(
+              new Uint8Array(
+                [128, 128, 255, 255].concat(
+                  [128, 128, 255, 255],
+                  [128, 128, 255, 255],
+                  [128, 128, 255, 255],
+                ),
+              ),
+              2,
+              2,
+            )
+          },
+        },
+      )
+
+      const exported = (prepared.scene.children[0] as THREE.Mesh)
+        .material as THREE.MeshStandardMaterial
+      expect(calls).toBe(1)
+      expect((exported.normalMap as { isCanvasTexture?: boolean }).isCanvasTexture).toBe(true)
+      expect(exported.normalScale.toArray()).toEqual([1, 1])
+      expect(material.normalMap).toBe(compressed)
+      expect(material.normalScale.toArray()).toEqual([0.5, 0.5])
+    })
+  })
+
+  test('reference mode keeps a stamped normal-map placeholder and its scale for the packer', async () => {
+    await withCanvasCapture(async () => {
+      const root = new THREE.Group()
+      const stamped = new THREE.CompressedTexture([], 4, 4)
+      stamped.userData.pascalTextureRef = {
+        v: 1,
+        kind: 'library-material',
+        src: `${STORAGE_ORIGIN}/storage/v1/object/public/materials/user/material/oak_normal_512.ktx2`,
+        map: 'normal',
+        colorSpace: 'linear',
+      }
+      const material = nodeMaterial({ normalMap: stamped }) as THREE.MeshStandardMaterial
+      material.normalScale.set(1, -1)
+      root.add(meshWithNodeMaterial(material))
+
+      const prepared = await prepareSceneForExportAsync(
+        root,
+        {},
+        {
+          textures: 'reference',
+          purpose: 'viewer',
+          decompressTexture: async () => {
+            throw new Error('by-reference placeholders must not be decompressed')
+          },
+        },
+      )
+
+      const exported = (prepared.scene.children[0] as THREE.Mesh)
+        .material as THREE.MeshStandardMaterial
+      expect(exported.normalMap?.userData.pascalTextureRef).toEqual(
+        stamped.userData.pascalTextureRef,
+      )
+      expect(exported.normalScale.toArray()).toEqual([1, -1])
+    })
+  })
+})
+
+describe('portable glass', () => {
+  test('see-through untextured surfaces become transmission glass in portable exports only', async () => {
+    const root = new THREE.Group()
+    const glass = new MeshStandardNodeMaterial({
+      color: '#3d9ed4',
+      transparent: true,
+      opacity: 0.3,
+      roughness: 0.1,
+    })
+    const tintedPlastic = new MeshStandardNodeMaterial({
+      color: '#3d9ed4',
+      transparent: true,
+      opacity: 0.8,
+    })
+    root.add(meshWithNodeMaterial(glass), meshWithNodeMaterial(tintedPlastic))
+
+    const portable = await prepareSceneForExportAsync(root, {})
+    const [exportedGlass, exportedPlastic] = portable.scene.children.map(
+      (child) => (child as THREE.Mesh).material as THREE.MeshPhysicalMaterial,
+    )
+    expect(exportedGlass!.isMeshPhysicalMaterial).toBe(true)
+    expect(exportedGlass!.transmission).toBe(1)
+    expect(exportedGlass!.transparent).toBe(false)
+    expect(exportedGlass!.opacity).toBe(1)
+    expect(exportedGlass!.roughness).toBeCloseTo(0.1)
+    // 30% authored opacity keeps 30% of the (linear) tint.
+    const tint = new THREE.Color('#3d9ed4')
+    expect(exportedGlass!.color.r).toBeCloseTo(tint.r + (1 - tint.r) * 0.7, 4)
+    expect(exportedGlass!.color.b).toBeCloseTo(tint.b + (1 - tint.b) * 0.7, 4)
+    expect(exportedPlastic!.isMeshPhysicalMaterial).toBeUndefined()
+    expect(exportedPlastic!.transparent).toBe(true)
+
+    const viewer = prepareSceneForExport(root, {}, { purpose: 'viewer' })
+    const kept = (viewer.scene.children[0] as THREE.Mesh).material as THREE.MeshStandardMaterial
+    expect((kept as { isMeshPhysicalMaterial?: boolean }).isMeshPhysicalMaterial).toBeUndefined()
+    expect(kept.transparent).toBe(true)
+    expect(kept.opacity).toBeCloseTo(0.3)
+
+    // USDZ has no transmission: the same prep hands glass its opacity back.
+    const usdz = createUsdzScene(portable.scene)
+    const usdzGlass = (usdz.children[0] as THREE.Mesh).material as THREE.MeshPhysicalMaterial
+    expect(usdzGlass.transmission).toBe(0)
+    expect(usdzGlass.transparent).toBe(true)
+    expect(usdzGlass.opacity).toBeCloseTo(0.3)
+    expect(exportedGlass!.transmission).toBe(1)
+  })
+})
+
+describe('portable clips', () => {
+  function swingDoorScene() {
+    const root = new THREE.Group()
+    const doorGroup = new THREE.Group()
+    const leaf = new THREE.Group()
+    leaf.userData.pascalSwingLeaf = { axis: 'y', openRotationY: Math.PI / 2 }
+    leaf.add(meshWithNodeMaterial(nodeMaterial()))
+    doorGroup.add(leaf)
+    root.add(doorGroup)
+    const doorId = 'door_portable'
+    sceneRegistry.nodes.set(doorId, doorGroup)
+    const nodes: Record<string, AnyNode> = {
+      [doorId]: { object: 'node', id: doorId, type: 'door', name: 'Door' } as unknown as AnyNode,
+    }
+    return { root, nodes, doorId }
+  }
+
+  test('GLB downloads keep door clips when asked, USDZ passes none', async () => {
+    const { root, nodes, doorId } = swingDoorScene()
+
+    const glb = await prepareSceneForExportAsync(root, nodes, { animations: 'keep' })
+    expect(glb.animations).toHaveLength(1)
+    expect(glb.animations[0]!.name).toBe(`${doorId}: open`)
+    const track = glb.animations[0]!.tracks[0]!
+    const targetUuid = track.name.split('.')[0]
+    expect(glb.scene.getObjectByProperty('uuid', targetUuid)).toBeDefined()
+    expect(glb.scene.getObjectByProperty('name', doorId)?.userData.clips).toEqual([
+      `${doorId}: open`,
+    ])
+
+    const usdz = await prepareSceneForExportAsync(root, nodes, { animations: 'none' })
+    expect(usdz.animations).toEqual([])
+    expect(usdz.scene.getObjectByProperty('name', doorId)?.userData.clips).toBeUndefined()
+
+    const legacy = await prepareSceneForExportAsync(root, nodes)
+    expect(legacy.animations).toEqual([])
+  })
+})

package/src/lib/glb-export.ts

@@ -35,9 +35,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 +73,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 +197,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 +260,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 +429,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 +486,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 +609,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)
         }
@@ -670,7 +784,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 +807,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 +1161,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 +1198,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/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)
+    })
+  }
+})

package/src/lib/level-duplication.ts

@@ -1,5 +1,5 @@
 import { cloneLevelSubtree } from '@pascal-app/core/clone-scene-graph'
-import type { AnyNode, AnyNodeId, LevelNode } from '@pascal-app/core/schema'
+import { type AnyNode, type AnyNodeId, type LevelNode, UnitNode } from '@pascal-app/core/schema'
 
 export type LevelDuplicatePreset =
   | 'everything'
@@ -117,7 +117,7 @@ export function buildLevelDuplicateCreateOps({
   levels: LevelNode[]
   preset: LevelDuplicatePreset
 }) {
-  const { clonedNodes, newLevelId } = cloneLevelSubtree(nodes, level.id)
+  const { clonedNodes, newLevelId, idMap } = cloneLevelSubtree(nodes, level.id)
   const parentBuildingId =
     (level.parentId as AnyNodeId | null) ?? findLevelBuildingId(nodes, level.id)
   const nextLevelNumber = level.level + 1
@@ -145,6 +145,36 @@ export function buildLevelDuplicateCreateOps({
     } as AnyNode
   })
 
+  if (parentBuildingId && nodes[parentBuildingId]?.type === 'building') {
+    for (const unit of Object.values(nodes)) {
+      if (
+        unit.type !== 'unit' ||
+        unit.parentId !== parentBuildingId ||
+        unit.members.length === 0 ||
+        !unit.members.every((id) => {
+          const zone = nodes[id]
+          const remapped = idMap.get(id)
+          return (
+            zone?.type === 'zone' &&
+            zone.parentId === level.id &&
+            remapped !== undefined &&
+            keptIds.has(remapped as AnyNodeId)
+          )
+        })
+      )
+        continue
+      cleanedNodes.push(
+        UnitNode.parse({
+          ...unit,
+          id: undefined,
+          parentId: parentBuildingId,
+          name: `${unit.name} copy`,
+          members: unit.members.map((id) => idMap.get(id)),
+        }),
+      )
+    }
+  }
+
   return {
     createOps: cleanedNodes.map((node) => ({
       node: