@pascal-app/editor 1.0.0 → 1.0.3

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

@@ -5,6 +5,8 @@ import {
   BoxGeometry,
   BufferGeometry,
   Color,
+  CompressedTexture,
+  DataTexture,
   DoubleSide,
   Float32BufferAttribute,
   FrontSide,
@@ -15,11 +17,13 @@ import {
   Mesh,
   MeshStandardMaterial,
   Quaternion,
+  Texture,
   Vector3,
 } from 'three'
 import { USDZExporter } from 'three/examples/jsm/exporters/USDZExporter.js'
 import {
   createUsdzScene,
+  decompressCanonicalNormalMaps,
   expandInstancedMeshes,
   freezeDeformedMeshes,
   normalizePortableScene,
@@ -345,6 +349,17 @@ function withCanvasCapture(run: (capture: () => ImageData) => void): void {
       putImageData: (image: ImageData) => {
         captured = image
       },
+      drawImage: () => {
+        if (!captured) throw new Error('Source canvas has no captured pixels')
+      },
+      getImageData: (_x: number, _y: number, width: number, height: number) =>
+        captured ??
+        ({
+          colorSpace: 'srgb',
+          data: new Uint8ClampedArray(width * height * 4),
+          height,
+          width,
+        } as ImageData),
     }),
   } as unknown as HTMLCanvasElement
   globals.document = {
@@ -364,3 +379,77 @@ function withCanvasCapture(run: (capture: () => ImageData) => void): void {
     else delete globals.document
   }
 }
+
+describe('portable normal maps', () => {
+  function flatNormalPixels(size: number): Uint8Array {
+    const pixels = new Uint8Array(size * size * 4)
+    for (let index = 0; index < pixels.length; index += 4) pixels.set([128, 128, 255, 255], index)
+    return pixels
+  }
+
+  test('decompresses a shared compressed normal map once before canonicalising it', async () => {
+    const compressed = new CompressedTexture([], 2, 2)
+    compressed.name = 'NormalGL_test'
+    compressed.repeat.set(2, 2)
+    const first = new MeshStandardMaterial({ normalMap: compressed })
+    first.normalScale.set(0.5, 0.5)
+    const second = new MeshStandardMaterial({ normalMap: compressed })
+    second.normalScale.set(0.5, -0.5)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), first), new Mesh(new BoxGeometry(), second))
+
+    let calls = 0
+    await decompressCanonicalNormalMaps(root, async () => {
+      calls += 1
+      return new DataTexture(flatNormalPixels(2), 2, 2)
+    })
+
+    expect(calls).toBe(1)
+    expect(first.normalMap).toBe(second.normalMap)
+    expect(first.normalMap?.repeat.toArray()).toEqual([2, 2])
+    expect(first.normalMap?.name).toBe('NormalGL_test')
+
+    withCanvasCapture(() => {
+      normalizePortableScene(root)
+    })
+
+    expect((first.normalMap as { isCanvasTexture?: boolean }).isCanvasTexture).toBe(true)
+    expect(first.normalMap).not.toBe(second.normalMap)
+    expect(first.normalScale.toArray()).toEqual([1, 1])
+    expect(second.normalScale.toArray()).toEqual([1, 1])
+  })
+
+  test('a compressed normal map that was not decompressed still fails loudly', () => {
+    const material = new MeshStandardMaterial({ normalMap: new CompressedTexture([], 2, 2) })
+    material.normalScale.set(0.5, 0.5)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), material))
+    withCanvasCapture(() => {
+      expect(() => normalizePortableScene(root)).toThrow('must be baked before portable export')
+    })
+  })
+
+  test('preserved normal maps keep their texture and normal scale', async () => {
+    const placeholder = new Texture()
+    placeholder.image = { width: 1, height: 1 }
+    const material = new MeshStandardMaterial({ normalMap: placeholder })
+    material.normalScale.set(1, -1)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), material))
+    const options = { preserveNormalMap: (texture: Texture) => texture === placeholder }
+
+    await decompressCanonicalNormalMaps(
+      root,
+      async () => {
+        throw new Error('preserved maps must not be decompressed')
+      },
+      options,
+    )
+    withCanvasCapture(() => {
+      normalizePortableScene(root, options)
+    })
+
+    expect(material.normalMap).toBe(placeholder)
+    expect(material.normalScale.toArray()).toEqual([1, -1])
+  })
+})

package/src/lib/portable-export.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three'
 import { StaticGeometryGenerator } from 'three-mesh-bvh'
+import { cloneExportUserData } from './export-user-data'
 
 const VERTEX_COLOR_UV_CHANNEL = 0
 const VERTEX_COLOR_TILE_SIZE = 8
@@ -64,7 +65,7 @@ function copyObjectState(source: THREE.Object3D, target: THREE.Object3D): void {
   target.layers.mask = source.layers.mask
   target.renderOrder = source.renderOrder
   target.frustumCulled = source.frustumCulled
-  target.userData = structuredClone(source.userData)
+  target.userData = cloneExportUserData(source.userData)
 }
 
 function replaceObject(source: THREE.Object3D, replacement: THREE.Object3D): void {
@@ -554,7 +555,7 @@ function cloneTextureSettings(source: THREE.Texture, target: THREE.Texture): voi
   target.flipY = source.flipY
   target.unpackAlignment = source.unpackAlignment
   target.colorSpace = THREE.NoColorSpace
-  target.userData = structuredClone(source.userData)
+  target.userData = cloneExportUserData(source.userData)
   target.needsUpdate = true
 }
 function materializeDataTextures(root: THREE.Object3D): void {
@@ -671,19 +672,68 @@ function canonicalNormalTexture(source: THREE.Texture, scale: THREE.Vector2): TH
   return texture
 }
 
-function canonicalizeNormalMaps(root: THREE.Object3D): void {
+export type PortableNormalizeOptions = {
+  /**
+   * Leave this normal map and its material's `normalScale` untouched. By-reference
+   * placeholders get their real bytes re-attached later, so baking the scale into
+   * placeholder pixels would drop both the reference and the strength.
+   */
+  preserveNormalMap?: (texture: THREE.Texture) => boolean
+}
+
+export type CompressedTextureDecompressor = (
+  texture: THREE.CompressedTexture,
+) => Promise<THREE.Texture>
+
+function canonicalNormalMaterials(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions,
+): THREE.MeshStandardMaterial[] {
   const materials = new Set<THREE.Material>()
   root.traverse((object) => {
     if (!(object as THREE.Mesh).isMesh) return
     for (const material of materialsOf(object as THREE.Mesh)) materials.add(material)
   })
-
-  const cache = new Map<THREE.Texture, Map<string, THREE.CanvasTexture>>()
+  const result: THREE.MeshStandardMaterial[] = []
   for (const material of materials) {
     const standard = material as THREE.MeshStandardMaterial
     if (!standard.normalMap || !standard.normalScale) continue
     if (standard.normalScale.x === 1 && standard.normalScale.y === 1) continue
-    const source = standard.normalMap
+    if (options.preserveNormalMap?.(standard.normalMap)) continue
+    result.push(standard)
+  }
+  return result
+}
+
+/**
+ * Canonicalizing a normal map reads its pixels on the CPU, which compressed
+ * (KTX2) textures cannot provide — decompress the ones that will be baked
+ * first. Runs before `normalizePortableScene` / `normalizeViewerArtifactMaterials`.
+ */
+export async function decompressCanonicalNormalMaps(
+  root: THREE.Object3D,
+  decompress: CompressedTextureDecompressor,
+  options: PortableNormalizeOptions = {},
+): Promise<void> {
+  const readable = new Map<THREE.Texture, THREE.Texture>()
+  for (const standard of canonicalNormalMaterials(root, options)) {
+    const source = standard.normalMap as THREE.CompressedTexture
+    if (!source.isCompressedTexture) continue
+    let texture = readable.get(source)
+    if (!texture) {
+      texture = await decompress(source)
+      cloneTextureSettings(source, texture)
+      readable.set(source, texture)
+      rememberDiscarded(root, source)
+    }
+    standard.normalMap = texture
+  }
+}
+
+function canonicalizeNormalMaps(root: THREE.Object3D, options: PortableNormalizeOptions): void {
+  const cache = new Map<THREE.Texture, Map<string, THREE.CanvasTexture>>()
+  for (const standard of canonicalNormalMaterials(root, options)) {
+    const source = standard.normalMap!
     const key = `${standard.normalScale.x}:${standard.normalScale.y}`
     let variants = cache.get(source)
     if (!variants) {
@@ -817,7 +867,10 @@ function clampPortableMaterialColors(root: THREE.Object3D): boolean {
   return clipped
 }
 
-export function normalizePortableScene(root: THREE.Object3D): string[] {
+export function normalizePortableScene(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions = {},
+): string[] {
   expandInstancedMeshes(root)
   root.updateMatrixWorld(true)
   freezeDeformedMeshes(root)
@@ -826,7 +879,7 @@ export function normalizePortableScene(root: THREE.Object3D): string[] {
   const clampedVertexColors = bakeVertexColors(root)
   const clampedHdr = clampedMaterialColors || clampedVertexColors
   canonicalizeAlphaMaps(root)
-  canonicalizeNormalMaps(root)
+  canonicalizeNormalMaps(root, options)
   bakeDoubleSidedMeshes(root)
   root.updateMatrixWorld(true)
   return clampedHdr
@@ -839,12 +892,15 @@ export function normalizePortableScene(root: THREE.Object3D): string[] {
  * Canonicalize baked static material details without freezing authored item
  * deformation that existing saved-viewer animation clips still target.
  */
-export function normalizeViewerArtifactMaterials(root: THREE.Object3D): string[] {
+export function normalizeViewerArtifactMaterials(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions = {},
+): string[] {
   const clampedMaterialColors = clampPortableMaterialColors(root)
   materializeDataTextures(root)
   const clampedVertexColors = bakeVertexColors(root, true)
   canonicalizeAlphaMaps(root)
-  canonicalizeNormalMaps(root)
+  canonicalizeNormalMaps(root, options)
   return clampedMaterialColors || clampedVertexColors
     ? [
         'Some rendered colors were outside the portable range (including colors brighter than the portable range) and were clipped to 0–1; the brightest areas may lose contrast.',
@@ -852,9 +908,26 @@ export function normalizeViewerArtifactMaterials(root: THREE.Object3D): string[]
     : []
 }
 
+/** Where the portable GLB conversion parks the authored opacity of glass it
+ * rewrote as transmission, so formats without transmission can fall back. */
+export const GLASS_OPACITY_USERDATA = 'pascalGlassOpacity'
+
 function cloneMaterialForUsdz(material: THREE.Material): THREE.Material {
   const clone = material.clone()
   clone.side = THREE.FrontSide
+  // USDPreviewSurface has no transmission and USDZExporter only writes
+  // `inputs:opacity`; hand glass back its authored opacity for Quick Look.
+  const physical = clone as THREE.MeshPhysicalMaterial
+  const authoredOpacity = clone.userData[GLASS_OPACITY_USERDATA]
+  if (
+    physical.isMeshPhysicalMaterial &&
+    physical.transmission > 0 &&
+    typeof authoredOpacity === 'number'
+  ) {
+    physical.transmission = 0
+    physical.transparent = true
+    physical.opacity = authoredOpacity
+  }
   return clone
 }
 
@@ -925,7 +998,7 @@ export function createUsdzScene(source: THREE.Object3D): THREE.Object3D {
     clone.visible = object.visible
     clone.layers.mask = object.layers.mask
     clone.renderOrder = object.renderOrder
-    clone.userData = structuredClone(object.userData)
+    clone.userData = cloneExportUserData(object.userData)
     for (const child of object.children) clone.add(cloneObject(child))
     return clone
   }

package/src/lib/print-shell-compiler-manifold-core.ts

@@ -1,6 +1,10 @@
-import ManifoldModule, { type Manifold as ManifoldSolid, type ManifoldToplevel } from 'manifold-3d'
+import type { Manifold as ManifoldSolid, ManifoldToplevel } from 'manifold-3d'
 import type { PrintShellCompileDiagnostic } from './print-shell-compiler-baseline'
-import type { ManifoldCompileOutput, ManifoldMeshData } from './print-shell-compiler-protocol'
+import type {
+  ManifoldCompileOutput,
+  ManifoldMeshData,
+  ManifoldRuntimeOptions,
+} from './print-shell-compiler-protocol'
 
 let modulePromise: Promise<ManifoldToplevel> | null = null
 const MANIFOLD_OUTPUT_WELD_EPSILON_METERS = 2e-5
@@ -8,14 +12,59 @@ const COLLINEAR_SEAM_CROSS_LENGTH_SQ = 1e-20
 
 type Triangle = [number, number, number]
 
-async function getManifoldModule(wasmUrl?: string): Promise<ManifoldToplevel> {
-  modulePromise ??= ManifoldModule(wasmUrl ? { locateFile: () => wasmUrl } : undefined).then(
-    (module) => {
+type ManifoldFactory = (config?: {
+  locateFile?: (path: string) => string
+}) => Promise<ManifoldToplevel>
+
+// manifold-3d's emscripten glue awaits import('node:module') behind a Node
+// check. The branch never executes in a browser, but webpack refuses to
+// *build* a graph that can reach it, so a static specifier here poisons every
+// external bundler that compiles this package's source (#715). The factory is
+// therefore loaded through an import() no bundler can trace: the bare
+// specifier resolves wherever node-style resolution exists at runtime (bun
+// tests, dev servers, bundlers that inline it anyway), and the version-pinned
+// CDN copy covers bundled browser builds that left the specifier unresolved —
+// emscripten then locates manifold.wasm relative to the glue's own URL. Hosts
+// that can't reach the CDN (offline, CSP) pass their own URLs through
+// configureManifoldRuntime.
+const MANIFOLD_VERSION = '3.5.1'
+const FALLBACK_MODULE_URL = `https://cdn.jsdelivr.net/npm/manifold-3d@${MANIFOLD_VERSION}/manifold.js`
+
+function importUntraced(specifier: string): Promise<{ default: ManifoldFactory }> {
+  return import(/* webpackIgnore: true */ /* @vite-ignore */ specifier)
+}
+
+async function loadManifoldFactory(moduleUrl?: string): Promise<ManifoldFactory> {
+  const specifiers = moduleUrl ? [moduleUrl] : ['manifold-3d', FALLBACK_MODULE_URL]
+  let lastError: unknown
+  for (const specifier of specifiers) {
+    try {
+      return (await importUntraced(specifier)).default
+    } catch (error) {
+      lastError = error
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error('Failed to load manifold-3d.')
+}
+
+async function getManifoldModule(runtime?: ManifoldRuntimeOptions): Promise<ManifoldToplevel> {
+  modulePromise ??= loadManifoldFactory(runtime?.moduleUrl)
+    .then((factory) => {
+      const wasmUrl = runtime?.wasmUrl
+      return factory(wasmUrl ? { locateFile: () => wasmUrl } : undefined)
+    })
+    .then((module) => {
       module.setup()
       return module
-    },
-  )
-  return modulePromise
+    })
+  try {
+    return await modulePromise
+  } catch (error) {
+    // A transient load failure (offline, blocked CDN) must not poison every
+    // later compile attempt with the cached rejection.
+    modulePromise = null
+    throw error
+  }
 }
 
 function manifoldMesh(
@@ -211,7 +260,7 @@ function elapsed(startedAt: number): number {
 
 export async function compileManifoldMeshData(
   meshes: ManifoldMeshData[],
-  wasmUrl?: string,
+  runtime?: ManifoldRuntimeOptions,
 ): Promise<ManifoldCompileOutput> {
   const startedAt = performance.now()
   const sourceNodeIds = Array.from(new Set(meshes.map((mesh) => mesh.nodeId))).sort()
@@ -238,7 +287,7 @@ export async function compileManifoldMeshData(
   }
 
   try {
-    const module = await getManifoldModule(wasmUrl)
+    const module = await getManifoldModule(runtime)
     for (const mesh of meshes) {
       try {
         solids.push(new module.Manifold(manifoldMesh(module, mesh)))

package/src/lib/print-shell-compiler-manifold-worker.ts

@@ -16,12 +16,25 @@ import {
 import type {
   ManifoldCompileOutput,
   ManifoldMeshData,
+  ManifoldRuntimeOptions,
   ManifoldWorkerRequest,
   ManifoldWorkerResponse,
 } from './print-shell-compiler-protocol'
 
 const WORKER_TIMEOUT_MS = 60_000
 
+let manifoldRuntime: ManifoldRuntimeOptions | undefined
+
+/**
+ * Overrides where the print-export worker loads the manifold-3d module and
+ * wasm from. See the loader in print-shell-compiler-manifold-core.ts for the
+ * default resolution order; hosts with restrictive networks should call this
+ * with self-hosted asset URLs before the first print export.
+ */
+export function configureManifoldRuntime(options: ManifoldRuntimeOptions | undefined): void {
+  manifoldRuntime = options
+}
+
 export type ManifoldCompileRunner = (meshes: ManifoldMeshData[]) => Promise<ManifoldCompileOutput>
 
 export type SemanticManifoldCompileOptions = SemanticPrintCompileOptions & {
@@ -76,7 +89,7 @@ export const runManifoldWorker: ManifoldCompileRunner = (meshes) => {
   const activeWorker = getWorker()
   const id = nextRequestId
   nextRequestId += 1
-  const request: ManifoldWorkerRequest = { id, meshes }
+  const request: ManifoldWorkerRequest = { id, meshes, runtime: manifoldRuntime }
   const transfer = meshes.flatMap((mesh) => [
     mesh.positions.buffer as ArrayBuffer,
     mesh.indices.buffer as ArrayBuffer,

package/src/lib/print-shell-compiler-manifold.worker.ts

@@ -10,7 +10,7 @@ const workerScope = self as unknown as {
 }
 
 workerScope.addEventListener('message', async (event) => {
-  const output = await compileManifoldMeshData(event.data.meshes)
+  const output = await compileManifoldMeshData(event.data.meshes, event.data.runtime)
   const response: ManifoldWorkerResponse = { id: event.data.id, ...output }
   const transfer: Transferable[] = []
   if (response.status === 'compiled') {

package/src/lib/print-shell-compiler-protocol.ts

@@ -22,9 +22,17 @@ export type ManifoldCompileOutput =
       durationMs: number
     }
 
+export type ManifoldRuntimeOptions = {
+  /** URL of the manifold-3d emscripten glue module. Defaults to the pinned CDN copy. */
+  moduleUrl?: string
+  /** URL of manifold.wasm. Defaults to resolving relative to the glue module. */
+  wasmUrl?: string
+}
+
 export type ManifoldWorkerRequest = {
   id: number
   meshes: ManifoldMeshData[]
+  runtime?: ManifoldRuntimeOptions
 }
 
 export type ManifoldWorkerResponse = ManifoldCompileOutput & { id: number }

package/src/lib/scene-clipboard.ts

@@ -382,7 +382,7 @@ function parseClipboardPayload(text: string): ClipboardPayload | null {
     if (materials.some((result) => !result.success)) return null
 
     const parsedNodes = nodes.filter((result) => result.success).map((result) => result.data)
-    const nodeIds = new Set(parsedNodes.map((node) => node.id))
+    const nodeIds = new Set<AnyNodeId>(parsedNodes.map((node) => node.id))
     const rootIds = candidate.rootIds as AnyNodeId[]
     if (rootIds.length === 0 || rootIds.some((id) => !nodeIds.has(id))) return null
 

package/src/lib/scene.test.ts

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { nodeRegistry, registerNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { z } from 'zod'
+import useEditor from '../store/use-editor'
+import { normalizeSceneGraphNodes, syncEditorSelectionFromCurrentScene } from './scene'
+
+const building = {
+  children: ['level_scene-root'],
+  id: 'building_scene-root',
+  object: 'node',
+  parentId: null,
+  position: [0, 0, 0],
+  rotation: [0, 0, 0],
+  type: 'building',
+  visible: true,
+}
+
+const level = {
+  children: ['wall_scene-root'],
+  id: 'level_scene-root',
+  level: 0,
+  object: 'node',
+  parentId: building.id,
+  type: 'level',
+  visible: true,
+}
+
+const wall = {
+  children: [],
+  end: [4, 0],
+  id: 'wall_scene-root',
+  object: 'node',
+  parentId: level.id,
+  start: [0, 0],
+  type: 'wall',
+  visible: true,
+}
+
+describe('scene selection synchronization', () => {
+  beforeEach(() => {
+    useViewer.getState().resetSelection()
+    useEditor.setState({ mode: 'select', phase: 'site', tool: null })
+  })
+
+  test('enters the first level when a scene graph is rooted at a building', () => {
+    useScene.setState({
+      nodes: {
+        [building.id]: building,
+        [level.id]: level,
+        [wall.id]: wall,
+      },
+      rootNodeIds: [building.id],
+    } as never)
+
+    syncEditorSelectionFromCurrentScene()
+
+    expect(useViewer.getState().selection).toMatchObject({
+      buildingId: building.id,
+      levelId: level.id,
+    })
+    expect(useEditor.getState().phase).toBe('structure')
+  })
+})
+
+describe('scene graph normalization', () => {
+  test('materializes registered schema defaults before the graph reaches renderers', () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    try {
+      registerNode({
+        kind: 'test-scene-normalization',
+        schema: z.object({
+          id: z.string(),
+          position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+          rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+          type: z.literal('test-scene-normalization'),
+        }),
+        schemaVersion: 1,
+      } as never)
+
+      expect(
+        normalizeSceneGraphNodes({
+          test: { id: 'test', type: 'test-scene-normalization' },
+          unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
+        }),
+      ).toEqual({
+        test: {
+          id: 'test',
+          position: [0, 0, 0],
+          rotation: [0, 0, 0],
+          type: 'test-scene-normalization',
+        },
+        unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
+      })
+    } finally {
+      restoreRegistry()
+    }
+  })
+})

package/src/lib/scene.ts

@@ -276,9 +276,13 @@ function getRestoredSelectionForScene(
 export function syncEditorSelectionFromCurrentScene() {
   const sceneNodes = useScene.getState().nodes as Record<string, any>
   const sceneRootIds = useScene.getState().rootNodeIds
-  const siteNode = sceneRootIds[0] ? sceneNodes[sceneRootIds[0]] : null
   const resolve = (child: any) => (typeof child === 'string' ? sceneNodes[child] : child)
-  const firstBuilding = siteNode?.children?.map(resolve).find((n: any) => n?.type === 'building')
+  const rootNodes = sceneRootIds.map((id) => sceneNodes[id]).filter(Boolean)
+  const firstBuilding =
+    rootNodes.find((node) => node.type === 'building') ??
+    rootNodes
+      .flatMap((node) => (Array.isArray(node.children) ? node.children.map(resolve) : []))
+      .find((node) => node?.type === 'building')
   const firstLevel = firstBuilding?.children?.map(resolve).find((n: any) => n?.type === 'level')
   const restoredEditorUiState = normalizePersistedEditorUiState(useEditor.getState())
   const shouldRestoreEditorUiState = hasCustomPersistedEditorUiState(restoredEditorUiState)
@@ -396,11 +400,25 @@ function hasUsableSceneGraph(sceneGraph?: SceneGraph | null): sceneGraph is Scen
   )
 }
 
+export function normalizeSceneGraphNodes(
+  nodes: Readonly<Record<string, unknown>>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(nodes).map(([id, value]) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return [id, value]
+      const type = (value as { type?: unknown }).type
+      if (typeof type !== 'string') return [id, value]
+      const parsed = nodeRegistry.get(type)?.schema.safeParse(value)
+      return [id, parsed?.success ? parsed.data : value]
+    }),
+  )
+}
+
 export function applySceneGraphToEditor(sceneGraph?: SceneGraph | null) {
   const defaultInstalledPlugins = editorHostPanelRegistry.getDefaultInstalledPluginIds()
   if (hasUsableSceneGraph(sceneGraph)) {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph
-    useScene.getState().setScene(nodes as any, rootNodeIds as any, {
+    useScene.getState().setScene(normalizeSceneGraphNodes(nodes) as any, rootNodeIds as any, {
       collections: collections as any,
       materials: materials as any,
       installedPlugins: installedPlugins ?? defaultInstalledPlugins,