From 0d60fe750fa80a0da63c0d17a8b6c05a48a5e32b Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Sat, 16 May 2026 20:43:00 +0000
Subject: [PATCH 1/3] feat: add Save button to PASCAL EDITOR to export layout
 JSON

- Added a `SaveButton` component to `viewer-toolbar.tsx`.
- Integrated it into `ViewerToolbarRight`.
- The button uses the central `useScene` state to extract `nodes` and `rootNodeIds`, formats them into a JSON Blob, and triggers a file download for layout preservation.
- Uses standard toolbar styling and the lucide-react 'Save' icon.

Co-authored-by: Luis-Dokkaebi <26320381+Luis-Dokkaebi@users.noreply.github.com>
---
 .../src/components/ui/viewer-toolbar.tsx      | 38 ++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/packages/editor/src/components/ui/viewer-toolbar.tsx b/packages/editor/src/components/ui/viewer-toolbar.tsx
index 53fe873eef..836b967107 100644
--- a/packages/editor/src/components/ui/viewer-toolbar.tsx
+++ b/packages/editor/src/components/ui/viewer-toolbar.tsx
@@ -1,8 +1,9 @@
 'use client'
 
 import { Icon as IconifyIcon } from '@iconify/react'
+import { useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Check, ChevronsLeft, ChevronsRight, Columns2, Eye, Footprints, Moon, Sun } from 'lucide-react'
+import { Check, ChevronsLeft, ChevronsRight, Columns2, Eye, Footprints, Moon, Sun, Save } from 'lucide-react'
 import { useCallback } from 'react'
 import { cn } from '../../lib/utils'
 import useEditor from '../../store/use-editor'
@@ -366,6 +367,39 @@ function PreviewButton() {
   )
 }
 
+function SaveButton() {
+  const nodes = useScene((state) => state.nodes)
+  const rootNodeIds = useScene((state) => state.rootNodeIds)
+
+  const handleSaveBuild = () => {
+    const sceneData = { nodes, rootNodeIds }
+    const json = JSON.stringify(sceneData, null, 2)
+    const blob = new Blob([json], { type: 'application/json' })
+    const url = URL.createObjectURL(blob)
+    const link = document.createElement('a')
+    link.href = url
+    const date = new Date().toISOString().split('T')[0]
+    link.download = `layout_${date}.json`
+    link.click()
+    URL.revokeObjectURL(url)
+  }
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button
+          className={cn(TOOLBAR_BTN)}
+          onClick={handleSaveBuild}
+          type="button"
+        >
+          <Save className="h-3.5 w-3.5" />
+        </button>
+      </TooltipTrigger>
+      <TooltipContent side="bottom">Save Build</TooltipContent>
+    </Tooltip>
+  )
+}
+
 // ── Composed toolbar sections ───────────────────────────────────────────────
 
 export function ViewerToolbarLeft() {
@@ -390,6 +424,8 @@ export function ViewerToolbarRight() {
       <div className="my-1.5 w-px bg-border/50" />
       <WalkthroughButton />
       <PreviewButton />
+      <div className="my-1.5 w-px bg-border/50" />
+      <SaveButton />
     </div>
   )
 }

From 0a0c7bf06343b1520bc88a7469bc8df899e986af Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 29 May 2026 03:11:09 +0000
Subject: [PATCH 2/3] =?UTF-8?q?feat:=20add=20Holtmont=20=E2=86=94=20editor?=
 =?UTF-8?q?=20postMessage=20bridge?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implementa el protocolo completo de comunicación iframe para
integrar el editor Pascal dentro de REAL-HOLTMONT (Vue 3).

Protocolo:
- PASCAL_READY: emitido al montar el listener para eliminar
  carreras de tiempo con el padre.
- HOLTMONT_3D_IMPORT: aplica la escena recibida al store via
  setScene() (migrations + orphan cleanup + dirty marks).
  Collections se restauran con setState si vienen no vacías.
- HOLTMONT_3D_IMPORT_ACK: enviado al padre tras aplicar la
  escena con éxito, para detener los reintentos cada 800ms.
- HOLTMONT_3D_EXPORT: botón "Guardar en Holtmont" en
  ViewerToolbarLeft que envía {nodes, rootNodeIds, collections}.

Archivos añadidos/modificados:
- apps/editor/app/holtmont-bridge.tsx  (nuevo — cliente)
- apps/editor/app/layout.tsx           (monta HoltmontBridge)
- apps/editor/app/test-holtmont/page.tsx (página de prueba)
- packages/editor/src/components/ui/HoltmontExportButton.tsx (nuevo)
- packages/editor/src/components/ui/viewer-toolbar.tsx (ViewerToolbarLeft)

https://claude.ai/code/session_01T8wymt2MFFyrZ61TzFNg5b
---
 apps/editor/app/holtmont-bridge.tsx           |  68 ++++++
 apps/editor/app/layout.tsx                    |   2 +
 apps/editor/app/test-holtmont/page.tsx        | 220 ++++++++++++++++++
 .../components/ui/HoltmontExportButton.tsx    |  35 +++
 .../src/components/ui/viewer-toolbar.tsx      |   4 +
 5 files changed, 329 insertions(+)
 create mode 100644 apps/editor/app/holtmont-bridge.tsx
 create mode 100644 apps/editor/app/test-holtmont/page.tsx
 create mode 100644 packages/editor/src/components/ui/HoltmontExportButton.tsx

diff --git a/apps/editor/app/holtmont-bridge.tsx b/apps/editor/app/holtmont-bridge.tsx
new file mode 100644
index 0000000000..9114e9aedb
--- /dev/null
+++ b/apps/editor/app/holtmont-bridge.tsx
@@ -0,0 +1,68 @@
+'use client'
+
+import { useScene } from '@pascal-app/core'
+import { useEffect } from 'react'
+
+export function HoltmontBridge() {
+  useEffect(() => {
+    const isIframe = window.parent !== window.self
+
+    function postToParent(payload: Record<string, unknown>) {
+      if (isIframe) {
+        window.parent.postMessage(payload, '*')
+      }
+    }
+
+    function handleMessage(event: MessageEvent) {
+      const data = event.data as Record<string, unknown> | null
+      if (!data || data.type !== 'HOLTMONT_3D_IMPORT') return
+
+      try {
+        const projectData = data.projectData as Record<string, unknown> | undefined
+        if (!projectData?.nodes) {
+          console.warn('[HoltmontBridge] HOLTMONT_3D_IMPORT: missing projectData.nodes — ignored')
+          return
+        }
+
+        const nodes = projectData.nodes as Record<string, unknown>
+        const rootNodeIds = Array.isArray(projectData.rootNodeIds)
+          ? (projectData.rootNodeIds as string[])
+          : []
+        const collections =
+          projectData.collections && typeof projectData.collections === 'object'
+            ? (projectData.collections as Record<string, unknown>)
+            : {}
+
+        console.log('[HoltmontBridge] Received HOLTMONT_3D_IMPORT:', {
+          nodeCount: Object.keys(nodes).length,
+          rootNodeIds,
+        })
+
+        // setScene runs migrations, removes orphans, marks all nodes dirty, notifies subscribers
+        useScene.getState().setScene(nodes as any, rootNodeIds)
+
+        // setScene always resets collections to {}; restore them if present
+        if (Object.keys(collections).length > 0) {
+          useScene.setState({ collections: collections as any })
+        }
+
+        console.log('[HoltmontBridge] Scene applied — sending HOLTMONT_3D_IMPORT_ACK')
+        postToParent({ type: 'HOLTMONT_3D_IMPORT_ACK' })
+      } catch (err) {
+        console.error('[HoltmontBridge] Failed to apply imported scene:', err)
+      }
+    }
+
+    window.addEventListener('message', handleMessage)
+
+    // Signal to parent that the editor is ready to receive scenes
+    postToParent({ type: 'PASCAL_READY' })
+    console.log('[HoltmontBridge] Listener mounted — PASCAL_READY sent')
+
+    return () => {
+      window.removeEventListener('message', handleMessage)
+    }
+  }, [])
+
+  return null
+}
diff --git a/apps/editor/app/layout.tsx b/apps/editor/app/layout.tsx
index 5257d59bf1..93e7b5b2e2 100644
--- a/apps/editor/app/layout.tsx
+++ b/apps/editor/app/layout.tsx
@@ -4,6 +4,7 @@ import { Barlow } from 'next/font/google'
 import localFont from 'next/font/local'
 import Script from 'next/script'
 import './globals.css'
+import { HoltmontBridge } from './holtmont-bridge'
 
 const geistSans = localFont({
   src: './fonts/GeistVF.woff',
@@ -41,6 +42,7 @@ export default function RootLayout({
         )}
       </head>
       <body className="font-sans">
+        <HoltmontBridge />
         {children}
         {process.env.NODE_ENV === 'development' && <Agentation />}
       </body>
diff --git a/apps/editor/app/test-holtmont/page.tsx b/apps/editor/app/test-holtmont/page.tsx
new file mode 100644
index 0000000000..6b36f5bb90
--- /dev/null
+++ b/apps/editor/app/test-holtmont/page.tsx
@@ -0,0 +1,220 @@
+'use client'
+
+import { useEffect, useRef, useState } from 'react'
+
+// Minimal test scene: Site → Building → Level → 4 walls + slab + ceiling
+const TEST_SCENE = {
+  nodes: {
+    'site-test': {
+      object: 'node',
+      id: 'site-test',
+      type: 'site',
+      parentId: null,
+      visible: true,
+      metadata: {},
+      position: [0, 0, 0],
+      rotation: 0,
+      children: ['building-test'],
+    },
+    'building-test': {
+      object: 'node',
+      id: 'building-test',
+      type: 'building',
+      parentId: 'site-test',
+      visible: true,
+      metadata: {},
+      position: [0, 0, 0],
+      rotation: 0,
+      children: ['level-test'],
+    },
+    'level-test': {
+      object: 'node',
+      id: 'level-test',
+      type: 'level',
+      parentId: 'building-test',
+      visible: true,
+      metadata: {},
+      position: [0, 0, 0],
+      rotation: 0,
+      level: 0,
+      children: ['wall-n', 'wall-s', 'wall-e', 'wall-w', 'slab-test', 'ceiling-test'],
+    },
+    'wall-n': {
+      object: 'node',
+      id: 'wall-n',
+      type: 'wall',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      start: [-4, 0],
+      end: [4, 0],
+      height: 3,
+      thickness: 0.2,
+      children: [],
+    },
+    'wall-s': {
+      object: 'node',
+      id: 'wall-s',
+      type: 'wall',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      start: [4, -6],
+      end: [-4, -6],
+      height: 3,
+      thickness: 0.2,
+      children: [],
+    },
+    'wall-e': {
+      object: 'node',
+      id: 'wall-e',
+      type: 'wall',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      start: [4, 0],
+      end: [4, -6],
+      height: 3,
+      thickness: 0.2,
+      children: [],
+    },
+    'wall-w': {
+      object: 'node',
+      id: 'wall-w',
+      type: 'wall',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      start: [-4, -6],
+      end: [-4, 0],
+      height: 3,
+      thickness: 0.2,
+      children: [],
+    },
+    'slab-test': {
+      object: 'node',
+      id: 'slab-test',
+      type: 'slab',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      position: [0, 0, 0],
+      rotation: 0,
+      points: [
+        [-4, 0],
+        [4, 0],
+        [4, -6],
+        [-4, -6],
+      ],
+      thickness: 0.2,
+      children: [],
+    },
+    'ceiling-test': {
+      object: 'node',
+      id: 'ceiling-test',
+      type: 'ceiling',
+      parentId: 'level-test',
+      visible: true,
+      metadata: {},
+      position: [0, 0, 0],
+      rotation: 0,
+      points: [
+        [-4, 0],
+        [4, 0],
+        [4, -6],
+        [-4, -6],
+      ],
+      thickness: 0.1,
+      height: 3,
+      children: [],
+    },
+  },
+  rootNodeIds: ['site-test'],
+  collections: {},
+}
+
+export default function TestHoltmontPage() {
+  const iframeRef = useRef<HTMLIFrameElement>(null)
+  const [log, setLog] = useState<string[]>([])
+  const [ready, setReady] = useState(false)
+
+  const appendLog = (msg: string) =>
+    setLog((prev) => [`${new Date().toISOString().slice(11, 23)} ${msg}`, ...prev].slice(0, 50))
+
+  useEffect(() => {
+    const handler = (event: MessageEvent) => {
+      const data = event.data as Record<string, unknown> | null
+      if (!data?.type) return
+
+      if (data.type === 'PASCAL_READY') {
+        appendLog('← PASCAL_READY received')
+        setReady(true)
+      } else if (data.type === 'HOLTMONT_3D_IMPORT_ACK') {
+        appendLog('← HOLTMONT_3D_IMPORT_ACK received')
+      } else if (data.type === 'HOLTMONT_3D_EXPORT') {
+        const exportData = data.data as Record<string, unknown>
+        appendLog(
+          `← HOLTMONT_3D_EXPORT received (${Object.keys(exportData?.nodes ?? {}).length} nodes)`,
+        )
+      }
+    }
+
+    window.addEventListener('message', handler)
+    return () => window.removeEventListener('message', handler)
+  }, [])
+
+  const sendScene = () => {
+    const iframe = iframeRef.current
+    if (!iframe?.contentWindow) return
+    appendLog('→ Sending HOLTMONT_3D_IMPORT...')
+    iframe.contentWindow.postMessage({ type: 'HOLTMONT_3D_IMPORT', projectData: TEST_SCENE }, '*')
+  }
+
+  const sendAgain = () => {
+    setReady(false)
+    sendScene()
+  }
+
+  return (
+    <div style={{ display: 'flex', height: '100vh', fontFamily: 'monospace' }}>
+      <div style={{ width: 280, padding: 16, borderRight: '1px solid #333', background: '#111', color: '#eee', overflowY: 'auto' }}>
+        <h2 style={{ margin: '0 0 12px', fontSize: 14 }}>Holtmont Bridge Test</h2>
+
+        <div style={{ marginBottom: 12 }}>
+          <div style={{ fontSize: 11, color: ready ? '#4ade80' : '#facc15', marginBottom: 8 }}>
+            Editor status: {ready ? '✓ READY' : 'waiting…'}
+          </div>
+          <button
+            disabled={!ready}
+            onClick={sendScene}
+            style={{ width: '100%', padding: '6px 0', marginBottom: 6, cursor: ready ? 'pointer' : 'not-allowed', background: ready ? '#16a34a' : '#374151', color: '#fff', border: 'none', borderRadius: 4, fontSize: 12 }}
+          >
+            Send test scene (IMPORT)
+          </button>
+          <button
+            onClick={sendAgain}
+            style={{ width: '100%', padding: '6px 0', cursor: 'pointer', background: '#1d4ed8', color: '#fff', border: 'none', borderRadius: 4, fontSize: 12 }}
+          >
+            Force resend (reload test)
+          </button>
+        </div>
+
+        <div style={{ fontSize: 10, color: '#9ca3af', marginBottom: 4 }}>Log (newest first):</div>
+        <div style={{ fontSize: 10, lineHeight: 1.6 }}>
+          {log.map((entry, i) => (
+            <div key={i} style={{ color: entry.includes('←') ? '#86efac' : '#93c5fd' }}>
+              {entry}
+            </div>
+          ))}
+        </div>
+      </div>
+
+      <iframe
+        ref={iframeRef}
+        src="/"
+        style={{ flex: 1, border: 'none' }}
+        title="Pascal Editor"
+      />
+    </div>
+  )
+}
diff --git a/packages/editor/src/components/ui/HoltmontExportButton.tsx b/packages/editor/src/components/ui/HoltmontExportButton.tsx
new file mode 100644
index 0000000000..40c98b4e36
--- /dev/null
+++ b/packages/editor/src/components/ui/HoltmontExportButton.tsx
@@ -0,0 +1,35 @@
+'use client'
+
+import { useScene } from '@pascal-app/core'
+import { Upload } from 'lucide-react'
+import { cn } from '../../lib/utils'
+import { Tooltip, TooltipContent, TooltipTrigger } from './primitives/tooltip'
+
+const TOOLBAR_BTN =
+  'flex items-center justify-center w-8 text-muted-foreground/80 transition-colors hover:bg-white/8 hover:text-foreground/90'
+
+export function HoltmontExportButton() {
+  const handleExport = () => {
+    if (typeof window === 'undefined' || window.parent === window.self) return
+    const { nodes, rootNodeIds, collections } = useScene.getState()
+    window.parent.postMessage(
+      { type: 'HOLTMONT_3D_EXPORT', data: { nodes, rootNodeIds, collections } },
+      '*',
+    )
+    console.log('[HoltmontBridge] HOLTMONT_3D_EXPORT sent:', {
+      nodeCount: Object.keys(nodes).length,
+      rootNodeIds,
+    })
+  }
+
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button className={cn(TOOLBAR_BTN)} onClick={handleExport} type="button">
+          <Upload className="h-3.5 w-3.5" />
+        </button>
+      </TooltipTrigger>
+      <TooltipContent side="bottom">Guardar en Holtmont</TooltipContent>
+    </Tooltip>
+  )
+}
diff --git a/packages/editor/src/components/ui/viewer-toolbar.tsx b/packages/editor/src/components/ui/viewer-toolbar.tsx
index 836b967107..0f7647ff85 100644
--- a/packages/editor/src/components/ui/viewer-toolbar.tsx
+++ b/packages/editor/src/components/ui/viewer-toolbar.tsx
@@ -4,6 +4,7 @@ import { Icon as IconifyIcon } from '@iconify/react'
 import { useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { Check, ChevronsLeft, ChevronsRight, Columns2, Eye, Footprints, Moon, Sun, Save } from 'lucide-react'
+import { HoltmontExportButton } from './HoltmontExportButton'
 import { useCallback } from 'react'
 import { cn } from '../../lib/utils'
 import useEditor from '../../store/use-editor'
@@ -407,6 +408,9 @@ export function ViewerToolbarLeft() {
     <>
       <CollapseSidebarButton />
       <ViewModeControl />
+      <div className={TOOLBAR_CONTAINER}>
+        <HoltmontExportButton />
+      </div>
     </>
   )
 }

From cd4936eff4b8160df20c41ba0a5f4ec35a4f8e07 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 8 Sep 2026 19:15:38 +0000
Subject: [PATCH 3/3] El plano 3D se dibuja: valida lo que llega y detecta bien
 el backend
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

El Plano 3D de la Pre Work Order salía en negro con cualquier diseño. Eran dos
fallos independientes, y los dos dejaban el mismo síntoma: la interfaz entera
bien y el lienzo vacío, sin ningún aviso.

1. WebGPU se daba por disponible con `'gpu' in navigator`. Chromium expone
   `navigator.gpu` en máquinas donde el dispositivo no se puede crear, y ahí
   three cae solo a WebGL2 ("WebGPURenderer: WebGPU is not available, running
   under WebGL2 backend") mientras el visor seguía montando la tubería TSL de
   post-proceso, que es WebGPU puro. Resultado: nada dibujado y la consola
   llena de "GL_INVALID_OPERATION: Feedback loop formed between Framebuffer and
   active Texture". Ahora se comprueba el backend que quedó
   (`renderer.backend.isWebGPUBackend`), que para cuando corre el efecto ya es
   el definitivo porque el Canvas espera a `renderer.init()`.

2. `useScene.setScene()` no valida: guarda el objeto tal cual. Un nodo con un
   campo de la forma equivocada —una puerta con `position: 0.5` en vez de
   `[x, y, z]`, que es lo que mandaba el generador de Holtmont— importaba sin
   quejarse y reventaba después dentro del `useFrame` de `DoorSystem`, matando
   el bucle de render. El puente ahora pasa cada nodo por `AnyNode` antes de
   tocar el store: rellena los valores por defecto que `setScene` no rellena,
   descarta lo que no se puede dibujar y responde con `HOLTMONT_3D_IMPORT_ACK`
   (con la lista de descartes) o `HOLTMONT_3D_IMPORT_ERROR`. Una escena que no
   deja ningún nodo en pie se rechaza y la anterior se queda en pantalla, en
   vez de sustituirla por una vacía.

De paso:

- `LevelNode.children` no admitía ids de `item`, aunque su propia descripción
  los nombra y la herramienta de muebles crea los nodos con el nivel como
  padre. Un nivel amueblado no pasaba `LevelNode.parse()`.
- Los muebles llegan con el nombre en `metadata.holtmontAsset` y el puente los
  resuelve contra `CATALOG_ITEMS`: el catálogo de modelos vive aquí, no en el
  generador.

Pruebas

- `bun test` (13): cada nodo de cada escena de `public/holtmont-fixtures/`
  contra el Zod real, más las escenas rotas (puerta con `position` numérico,
  tipo desconocido, mensaje sin nodos, huérfanos en cascada).
- `node apps/editor/scripts/holtmont-smoke.mjs`: abre el editor en un navegador,
  le manda las cinco escenas por `postMessage` y comprueba la geometría
  dibujada, no el store. Las cinco pasan: cuarto 5x4 con puerta, bodega 12x8 con
  dos puertas y cuatro ventanas, oficina sin vanos, casa de dos pisos con
  ventanas al frente y atrás (dos niveles, escalera y techo) y cuarto amueblado.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012KkjqdcUER3S3GX2ahziMQ
---
 README.md                                     |  26 +
 apps/editor/app/holtmont-bridge.tsx           | 103 ++-
 apps/editor/app/test-holtmont/page.tsx        | 324 +++++-----
 apps/editor/lib/holtmont-import.test.ts       | 197 ++++++
 apps/editor/lib/holtmont-import.ts            | 283 +++++++++
 apps/editor/package.json                      |   4 +-
 ...dega-12x8-dos-puertas-cuatro-ventanas.json | 400 ++++++++++++
 ...asa-dos-pisos-ventanas-frente-y-atras.json | 601 ++++++++++++++++++
 .../cuarto-5x4-con-puerta.json                | 277 ++++++++
 .../holtmont-fixtures/cuarto-amueblado.json   | 386 +++++++++++
 .../public/holtmont-fixtures/index.json       |   7 +
 .../holtmont-fixtures/oficina-sin-vanos.json  | 252 ++++++++
 apps/editor/scripts/holtmont-smoke.mjs        | 183 ++++++
 bun.lock                                      |   5 +
 package.json                                  |   1 +
 packages/core/package.json                    |   5 +
 packages/core/src/schema/nodes/level.ts       |   6 +
 .../src/components/viewer/post-processing.tsx |  27 +-
 18 files changed, 2868 insertions(+), 219 deletions(-)
 create mode 100644 apps/editor/lib/holtmont-import.test.ts
 create mode 100644 apps/editor/lib/holtmont-import.ts
 create mode 100644 apps/editor/public/holtmont-fixtures/bodega-12x8-dos-puertas-cuatro-ventanas.json
 create mode 100644 apps/editor/public/holtmont-fixtures/casa-dos-pisos-ventanas-frente-y-atras.json
 create mode 100644 apps/editor/public/holtmont-fixtures/cuarto-5x4-con-puerta.json
 create mode 100644 apps/editor/public/holtmont-fixtures/cuarto-amueblado.json
 create mode 100644 apps/editor/public/holtmont-fixtures/index.json
 create mode 100644 apps/editor/public/holtmont-fixtures/oficina-sin-vanos.json
 create mode 100644 apps/editor/scripts/holtmont-smoke.mjs

diff --git a/README.md b/README.md
index 1abe030079..bd327af52c 100644
--- a/README.md
+++ b/README.md
@@ -380,6 +380,32 @@ turbo build
 turbo build --filter=@pascal-app/core
 ```
 
+### Holtmont bridge tests
+
+The Holtmont Pre Work Order embeds this editor in an iframe and pushes a scene
+in with `postMessage` (`apps/editor/app/holtmont-bridge.tsx`). Two suites guard
+that path:
+
+```bash
+# 1. Schema contract — every node of every generated scene must pass `AnyNode`.
+bun test
+
+# 2. Render smoke test — drives the real editor in a browser and checks the
+#    geometry actually exists, not just the store. Needs the dev server up.
+bun run --cwd apps/editor dev            # in another terminal
+node apps/editor/scripts/holtmont-smoke.mjs --screenshots=/tmp/holtmont
+```
+
+The scenes under `apps/editor/public/holtmont-fixtures/` are generated by
+`scripts/generar_escenas_pascal.py` in the HOLTMONT-PYTHON repository; regenerate
+them there whenever its scene builder changes. `/test-holtmont` is the manual
+version of the same harness.
+
+Why the render smoke test exists: `useScene.setScene()` does not validate, so a
+malformed node imports cleanly and only fails later inside a `useFrame`, which
+kills the react-three-fiber render loop. The store looks fine and the canvas
+goes black. Only a check on drawn geometry tells the two apart.
+
 ### Publishing Packages
 
 ```bash
diff --git a/apps/editor/app/holtmont-bridge.tsx b/apps/editor/app/holtmont-bridge.tsx
index 9114e9aedb..74f6c2d0e7 100644
--- a/apps/editor/app/holtmont-bridge.tsx
+++ b/apps/editor/app/holtmont-bridge.tsx
@@ -1,7 +1,10 @@
 'use client'
 
-import { useScene } from '@pascal-app/core'
+import { sceneRegistry, useScene } from '@pascal-app/core'
+import { CATALOG_ITEMS } from '@pascal-app/editor'
 import { useEffect } from 'react'
+import { Box3 } from 'three'
+import { HoltmontImportError, normalizeHoltmontScene } from '../lib/holtmont-import'
 
 export function HoltmontBridge() {
   useEffect(() => {
@@ -17,47 +20,91 @@ export function HoltmontBridge() {
       const data = event.data as Record<string, unknown> | null
       if (!data || data.type !== 'HOLTMONT_3D_IMPORT') return
 
+      let scene: ReturnType<typeof normalizeHoltmontScene>
       try {
-        const projectData = data.projectData as Record<string, unknown> | undefined
-        if (!projectData?.nodes) {
-          console.warn('[HoltmontBridge] HOLTMONT_3D_IMPORT: missing projectData.nodes — ignored')
-          return
-        }
+        // Valida contra el esquema real del editor antes de tocar el store: un
+        // nodo mal formado revienta después, dentro del bucle de render, y ahí
+        // ya no hay forma de avisar — solo queda el lienzo en negro.
+        scene = normalizeHoltmontScene(data.projectData, CATALOG_ITEMS)
+      } catch (err) {
+        const reason = err instanceof HoltmontImportError ? err.message : String(err)
+        console.error('[HoltmontBridge] HOLTMONT_3D_IMPORT rechazado:', reason)
+        // La escena que ya estaba montada se queda como está: sustituirla por
+        // una vacía convierte un import fallido en una pantalla negra.
+        postToParent({ type: 'HOLTMONT_3D_IMPORT_ERROR', reason, dropped: [] })
+        return
+      }
 
-        const nodes = projectData.nodes as Record<string, unknown>
-        const rootNodeIds = Array.isArray(projectData.rootNodeIds)
-          ? (projectData.rootNodeIds as string[])
-          : []
-        const collections =
-          projectData.collections && typeof projectData.collections === 'object'
-            ? (projectData.collections as Record<string, unknown>)
-            : {}
-
-        console.log('[HoltmontBridge] Received HOLTMONT_3D_IMPORT:', {
-          nodeCount: Object.keys(nodes).length,
-          rootNodeIds,
+      try {
+        console.log('[HoltmontBridge] HOLTMONT_3D_IMPORT recibido:', {
+          nodeCount: Object.keys(scene.nodes).length,
+          rootNodeIds: scene.rootNodeIds,
+          dropped: scene.dropped,
         })
 
-        // setScene runs migrations, removes orphans, marks all nodes dirty, notifies subscribers
-        useScene.getState().setScene(nodes as any, rootNodeIds)
+        // setScene corre migraciones, quita huérfanos, marca todo sucio y avisa
+        // a los suscriptores.
+        useScene.getState().setScene(scene.nodes, scene.rootNodeIds)
 
-        // setScene always resets collections to {}; restore them if present
-        if (Object.keys(collections).length > 0) {
-          useScene.setState({ collections: collections as any })
+        // setScene siempre deja collections en {}; se restauran si venían.
+        if (Object.keys(scene.collections).length > 0) {
+          useScene.setState({ collections: scene.collections as never })
         }
 
-        console.log('[HoltmontBridge] Scene applied — sending HOLTMONT_3D_IMPORT_ACK')
-        postToParent({ type: 'HOLTMONT_3D_IMPORT_ACK' })
+        postToParent({
+          type: 'HOLTMONT_3D_IMPORT_ACK',
+          nodeCount: Object.keys(scene.nodes).length,
+          dropped: scene.dropped,
+        })
       } catch (err) {
-        console.error('[HoltmontBridge] Failed to apply imported scene:', err)
+        console.error('[HoltmontBridge] No se pudo aplicar la escena importada:', err)
+        postToParent({
+          type: 'HOLTMONT_3D_IMPORT_ERROR',
+          reason: String(err),
+          dropped: scene.dropped,
+        })
       }
     }
 
     window.addEventListener('message', handleMessage)
 
-    // Signal to parent that the editor is ready to receive scenes
+    // Sonda de diagnóstico: dice qué se dibujó de verdad, no qué se guardó.
+    // La usa la prueba de humo (`scripts/holtmont-smoke.mjs`) para distinguir
+    // «la escena está en el store» de «la escena tiene geometría en pantalla»,
+    // que es justo la diferencia entre el bug del lienzo negro y el arreglo.
+    ;(window as unknown as Record<string, unknown>).__holtmontProbe = () => {
+      const nodes = useScene.getState().nodes
+      const resumen: Record<string, { total: number; conGeometria: number }> = {}
+      let mayorLado = 0
+
+      for (const [tipo, ids] of Object.entries(sceneRegistry.byType)) {
+        const entrada = { total: 0, conGeometria: 0 }
+        for (const id of ids) {
+          if (!nodes[id as keyof typeof nodes]) continue
+          entrada.total += 1
+          const objeto = sceneRegistry.nodes.get(id)
+          if (!objeto) continue
+          const caja = new Box3().setFromObject(objeto)
+          if (caja.isEmpty()) continue
+          const lado = Math.max(
+            caja.max.x - caja.min.x,
+            caja.max.y - caja.min.y,
+            caja.max.z - caja.min.z,
+          )
+          if (lado > 0.01) {
+            entrada.conGeometria += 1
+            mayorLado = Math.max(mayorLado, lado)
+          }
+        }
+        if (entrada.total > 0) resumen[tipo] = entrada
+      }
+
+      return { nodos: Object.keys(nodes).length, porTipo: resumen, mayorLado }
+    }
+
+    // Avisa al padre que el editor ya puede recibir escenas.
     postToParent({ type: 'PASCAL_READY' })
-    console.log('[HoltmontBridge] Listener mounted — PASCAL_READY sent')
+    console.log('[HoltmontBridge] Listener montado — PASCAL_READY enviado')
 
     return () => {
       window.removeEventListener('message', handleMessage)
diff --git a/apps/editor/app/test-holtmont/page.tsx b/apps/editor/app/test-holtmont/page.tsx
index 6b36f5bb90..9a84a3b493 100644
--- a/apps/editor/app/test-holtmont/page.tsx
+++ b/apps/editor/app/test-holtmont/page.tsx
@@ -1,145 +1,78 @@
 'use client'
 
-import { useEffect, useRef, useState } from 'react'
-
-// Minimal test scene: Site → Building → Level → 4 walls + slab + ceiling
-const TEST_SCENE = {
-  nodes: {
-    'site-test': {
-      object: 'node',
-      id: 'site-test',
-      type: 'site',
-      parentId: null,
-      visible: true,
-      metadata: {},
-      position: [0, 0, 0],
-      rotation: 0,
-      children: ['building-test'],
-    },
-    'building-test': {
-      object: 'node',
-      id: 'building-test',
-      type: 'building',
-      parentId: 'site-test',
-      visible: true,
-      metadata: {},
-      position: [0, 0, 0],
-      rotation: 0,
-      children: ['level-test'],
-    },
-    'level-test': {
-      object: 'node',
-      id: 'level-test',
-      type: 'level',
-      parentId: 'building-test',
-      visible: true,
-      metadata: {},
-      position: [0, 0, 0],
-      rotation: 0,
-      level: 0,
-      children: ['wall-n', 'wall-s', 'wall-e', 'wall-w', 'slab-test', 'ceiling-test'],
-    },
-    'wall-n': {
-      object: 'node',
-      id: 'wall-n',
-      type: 'wall',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      start: [-4, 0],
-      end: [4, 0],
-      height: 3,
-      thickness: 0.2,
-      children: [],
-    },
-    'wall-s': {
-      object: 'node',
-      id: 'wall-s',
-      type: 'wall',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      start: [4, -6],
-      end: [-4, -6],
-      height: 3,
-      thickness: 0.2,
-      children: [],
-    },
-    'wall-e': {
-      object: 'node',
-      id: 'wall-e',
-      type: 'wall',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      start: [4, 0],
-      end: [4, -6],
-      height: 3,
-      thickness: 0.2,
-      children: [],
-    },
-    'wall-w': {
-      object: 'node',
-      id: 'wall-w',
-      type: 'wall',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      start: [-4, -6],
-      end: [-4, 0],
-      height: 3,
-      thickness: 0.2,
-      children: [],
-    },
-    'slab-test': {
-      object: 'node',
-      id: 'slab-test',
-      type: 'slab',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      position: [0, 0, 0],
-      rotation: 0,
-      points: [
-        [-4, 0],
-        [4, 0],
-        [4, -6],
-        [-4, -6],
-      ],
-      thickness: 0.2,
-      children: [],
-    },
-    'ceiling-test': {
-      object: 'node',
-      id: 'ceiling-test',
-      type: 'ceiling',
-      parentId: 'level-test',
-      visible: true,
-      metadata: {},
-      position: [0, 0, 0],
-      rotation: 0,
-      points: [
-        [-4, 0],
-        [4, 0],
-        [4, -6],
-        [-4, -6],
-      ],
-      thickness: 0.1,
-      height: 3,
-      children: [],
-    },
-  },
-  rootNodeIds: ['site-test'],
-  collections: {},
+/**
+ * Banco de pruebas del puente con Holtmont.
+ *
+ * Carga las escenas que genera el agente (`public/holtmont-fixtures/`, escritas
+ * por `scripts/generar_escenas_pascal.py` del repositorio HOLTMONT-PYTHON) y las
+ * manda al editor por el mismo `postMessage` que usa la Pre Work Order. Sirve a
+ * mano y también para la prueba de humo con navegador
+ * (`scripts/holtmont-smoke.mjs`), que entra con `?scene=<nombre>` y lee el
+ * resultado de `window.__holtmontTest`.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+type Registro = { hora: string; texto: string; entrante: boolean }
+
+type EstadoDePrueba = {
+  ready: boolean
+  ack: Record<string, unknown> | null
+  error: Record<string, unknown> | null
+  enviada: string | null
+}
+
+declare global {
+  interface Window {
+    __holtmontTest?: EstadoDePrueba
+  }
 }
 
 export default function TestHoltmontPage() {
   const iframeRef = useRef<HTMLIFrameElement>(null)
-  const [log, setLog] = useState<string[]>([])
+  const [log, setLog] = useState<Registro[]>([])
   const [ready, setReady] = useState(false)
+  const [escenas, setEscenas] = useState<string[]>([])
+  const [seleccionada, setSeleccionada] = useState<string>('')
+  const estado = useRef<EstadoDePrueba>({ ready: false, ack: null, error: null, enviada: null })
+
+  const anotar = useCallback((texto: string, entrante = false) => {
+    setLog((prev) =>
+      [{ hora: new Date().toISOString().slice(11, 23), texto, entrante }, ...prev].slice(0, 60),
+    )
+  }, [])
 
-  const appendLog = (msg: string) =>
-    setLog((prev) => [`${new Date().toISOString().slice(11, 23)} ${msg}`, ...prev].slice(0, 50))
+  const publicarEstado = useCallback(() => {
+    window.__holtmontTest = { ...estado.current }
+  }, [])
+
+  // Catálogo de escenas disponibles y la que pide la URL (`?scene=`).
+  useEffect(() => {
+    publicarEstado()
+    const pedida = new URLSearchParams(window.location.search).get('scene')
+    fetch('/holtmont-fixtures/index.json')
+      .then((r) => r.json())
+      .then((lista: string[]) => {
+        setEscenas(lista)
+        setSeleccionada(pedida && lista.includes(pedida) ? pedida : (lista[0] ?? ''))
+      })
+      .catch((err) => anotar(`no se pudo leer el índice de escenas: ${err}`))
+  }, [anotar, publicarEstado])
+
+  const enviarEscena = useCallback(
+    async (nombre: string) => {
+      const iframe = iframeRef.current
+      if (!iframe?.contentWindow || !nombre) return
+      estado.current = { ...estado.current, ack: null, error: null, enviada: null }
+      publicarEstado()
+      anotar(`→ HOLTMONT_3D_IMPORT (${nombre})`)
+      const projectData = await fetch(`/holtmont-fixtures/${nombre}.json`).then((r) => r.json())
+      iframe.contentWindow.postMessage({ type: 'HOLTMONT_3D_IMPORT', projectData }, '*')
+      estado.current = { ...estado.current, enviada: nombre }
+      publicarEstado()
+    },
+    [anotar, publicarEstado],
+  )
 
   useEffect(() => {
     const handler = (event: MessageEvent) => {
@@ -147,74 +80,103 @@ export default function TestHoltmontPage() {
       if (!data?.type) return
 
       if (data.type === 'PASCAL_READY') {
-        appendLog('← PASCAL_READY received')
+        anotar('← PASCAL_READY', true)
         setReady(true)
+        estado.current = { ...estado.current, ready: true }
       } else if (data.type === 'HOLTMONT_3D_IMPORT_ACK') {
-        appendLog('← HOLTMONT_3D_IMPORT_ACK received')
+        const descartes = (data.dropped as unknown[]) ?? []
+        anotar(
+          `← HOLTMONT_3D_IMPORT_ACK (${data.nodeCount} nodos, ${descartes.length} descartes)`,
+          true,
+        )
+        estado.current = { ...estado.current, ack: data }
+      } else if (data.type === 'HOLTMONT_3D_IMPORT_ERROR') {
+        anotar(`← HOLTMONT_3D_IMPORT_ERROR: ${data.reason}`, true)
+        estado.current = { ...estado.current, error: data }
       } else if (data.type === 'HOLTMONT_3D_EXPORT') {
         const exportData = data.data as Record<string, unknown>
-        appendLog(
-          `← HOLTMONT_3D_EXPORT received (${Object.keys(exportData?.nodes ?? {}).length} nodes)`,
-        )
+        anotar(`← HOLTMONT_3D_EXPORT (${Object.keys(exportData?.nodes ?? {}).length} nodos)`, true)
+      } else {
+        return
       }
+      publicarEstado()
     }
 
     window.addEventListener('message', handler)
     return () => window.removeEventListener('message', handler)
-  }, [])
+  }, [anotar, publicarEstado])
 
-  const sendScene = () => {
-    const iframe = iframeRef.current
-    if (!iframe?.contentWindow) return
-    appendLog('→ Sending HOLTMONT_3D_IMPORT...')
-    iframe.contentWindow.postMessage({ type: 'HOLTMONT_3D_IMPORT', projectData: TEST_SCENE }, '*')
-  }
-
-  const sendAgain = () => {
-    setReady(false)
-    sendScene()
-  }
+  // Autoenvío en cuanto el editor avisa que está listo: así la prueba de humo
+  // no depende de un temporizador.
+  useEffect(() => {
+    if (ready && seleccionada && !estado.current.enviada) {
+      void enviarEscena(seleccionada)
+    }
+  }, [ready, seleccionada, enviarEscena])
 
   return (
     <div style={{ display: 'flex', height: '100vh', fontFamily: 'monospace' }}>
-      <div style={{ width: 280, padding: 16, borderRight: '1px solid #333', background: '#111', color: '#eee', overflowY: 'auto' }}>
-        <h2 style={{ margin: '0 0 12px', fontSize: 14 }}>Holtmont Bridge Test</h2>
-
-        <div style={{ marginBottom: 12 }}>
-          <div style={{ fontSize: 11, color: ready ? '#4ade80' : '#facc15', marginBottom: 8 }}>
-            Editor status: {ready ? '✓ READY' : 'waiting…'}
-          </div>
-          <button
-            disabled={!ready}
-            onClick={sendScene}
-            style={{ width: '100%', padding: '6px 0', marginBottom: 6, cursor: ready ? 'pointer' : 'not-allowed', background: ready ? '#16a34a' : '#374151', color: '#fff', border: 'none', borderRadius: 4, fontSize: 12 }}
-          >
-            Send test scene (IMPORT)
-          </button>
-          <button
-            onClick={sendAgain}
-            style={{ width: '100%', padding: '6px 0', cursor: 'pointer', background: '#1d4ed8', color: '#fff', border: 'none', borderRadius: 4, fontSize: 12 }}
-          >
-            Force resend (reload test)
-          </button>
+      <div
+        style={{
+          width: 320,
+          padding: 16,
+          borderRight: '1px solid #333',
+          background: '#111',
+          color: '#eee',
+          overflowY: 'auto',
+        }}
+      >
+        <h2 style={{ margin: '0 0 12px', fontSize: 14 }}>Puente Holtmont — banco de pruebas</h2>
+
+        <div style={{ fontSize: 11, color: ready ? '#4ade80' : '#facc15', marginBottom: 8 }}>
+          Editor: {ready ? '✓ listo' : 'esperando…'}
         </div>
 
-        <div style={{ fontSize: 10, color: '#9ca3af', marginBottom: 4 }}>Log (newest first):</div>
+        <select
+          onChange={(e) => setSeleccionada(e.target.value)}
+          style={{ width: '100%', marginBottom: 6, padding: 4, fontSize: 12 }}
+          value={seleccionada}
+        >
+          {escenas.map((nombre) => (
+            <option key={nombre} value={nombre}>
+              {nombre}
+            </option>
+          ))}
+        </select>
+
+        <button
+          data-testid="enviar-escena"
+          disabled={!(ready && seleccionada)}
+          onClick={() => void enviarEscena(seleccionada)}
+          style={{
+            width: '100%',
+            padding: '6px 0',
+            cursor: ready ? 'pointer' : 'not-allowed',
+            background: ready ? '#16a34a' : '#374151',
+            color: '#fff',
+            border: 'none',
+            borderRadius: 4,
+            fontSize: 12,
+            marginBottom: 12,
+          }}
+        >
+          Enviar escena (IMPORT)
+        </button>
+
+        <div style={{ fontSize: 10, color: '#9ca3af', marginBottom: 4 }}>Bitácora:</div>
         <div style={{ fontSize: 10, lineHeight: 1.6 }}>
-          {log.map((entry, i) => (
-            <div key={i} style={{ color: entry.includes('←') ? '#86efac' : '#93c5fd' }}>
-              {entry}
+          {log.map((entrada) => (
+            <div
+              key={`${entrada.hora}-${entrada.texto}`}
+              style={{ color: entrada.entrante ? '#86efac' : '#93c5fd' }}
+            >
+              {entrada.hora} {entrada.texto}
             </div>
           ))}
         </div>
       </div>
 
-      <iframe
-        ref={iframeRef}
-        src="/"
-        style={{ flex: 1, border: 'none' }}
-        title="Pascal Editor"
-      />
+      <iframe ref={iframeRef} src="/" style={{ flex: 1, border: 'none' }} title="Pascal Editor" />
     </div>
   )
 }
diff --git a/apps/editor/lib/holtmont-import.test.ts b/apps/editor/lib/holtmont-import.test.ts
new file mode 100644
index 0000000000..651359c34b
--- /dev/null
+++ b/apps/editor/lib/holtmont-import.test.ts
@@ -0,0 +1,197 @@
+/**
+ * El contrato con el generador de escenas de HOLTMONT-PYTHON.
+ *
+ * Las escenas de `public/holtmont-fixtures/` las escribe
+ * `scripts/generar_escenas_pascal.py` del repositorio de Holtmont, a partir de
+ * las mismas descripciones que se prueban allá. Aquí se validan contra el Zod
+ * de verdad del editor: si el generador vuelve a escribir un campo con la forma
+ * equivocada —una puerta con `position: 0.5` en vez de `[x, y, z]`, que es lo
+ * que dejaba el plano 3D en negro— esto se pone en rojo antes de que nadie
+ * abra el iframe.
+ *
+ *   bun test apps/editor/lib/holtmont-import.test.ts
+ */
+
+import { describe, expect, test } from 'bun:test'
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { type CatalogAsset, HoltmontImportError, normalizeHoltmontScene } from './holtmont-import'
+
+const FIXTURES_DIR = join(import.meta.dir, '..', 'public', 'holtmont-fixtures')
+
+const CATALOGO_DE_PRUEBA: CatalogAsset[] = [
+  {
+    id: 'double-bed',
+    category: 'bedroom',
+    name: 'Double Bed',
+    thumbnail: '/items/double-bed/thumbnail.webp',
+    src: '/items/double-bed/model.glb',
+    dimensions: [1.6, 0.6, 2],
+  },
+  {
+    id: 'office-table',
+    category: 'office',
+    name: 'Office Table',
+    thumbnail: '/items/office-table/thumbnail.webp',
+    src: '/items/office-table/model.glb',
+    dimensions: [1.4, 0.75, 0.7],
+  },
+]
+
+function leerFixture(nombre: string): unknown {
+  return JSON.parse(readFileSync(join(FIXTURES_DIR, `${nombre}.json`), 'utf-8'))
+}
+
+const NOMBRES_DE_FIXTURE = readdirSync(FIXTURES_DIR)
+  .filter((f) => f.endsWith('.json') && f !== 'index.json')
+  .map((f) => f.replace(/\.json$/, ''))
+
+describe('escenas generadas por el agente de Holtmont', () => {
+  test('el directorio de fixtures no está vacío', () => {
+    expect(NOMBRES_DE_FIXTURE.length).toBeGreaterThan(0)
+  })
+
+  for (const nombre of NOMBRES_DE_FIXTURE) {
+    test(`${nombre}: todos sus nodos pasan el esquema del editor`, () => {
+      const escena = normalizeHoltmontScene(leerFixture(nombre), CATALOGO_DE_PRUEBA)
+
+      // El único descarte tolerado es un mueble que no existe en el catálogo:
+      // cualquier otro significa que el generador escribió algo que el editor
+      // no sabe dibujar.
+      const inesperados = escena.dropped.filter((d) => !d.reason.startsWith('sin asset'))
+      expect(inesperados).toEqual([])
+
+      expect(Object.keys(escena.nodes).length).toBeGreaterThan(0)
+      expect(escena.rootNodeIds.length).toBeGreaterThan(0)
+      for (const raiz of escena.rootNodeIds) {
+        expect(escena.nodes[raiz]?.type).toBe('site')
+      }
+    })
+  }
+
+  test('cuarto-5x4-con-puerta: la puerta abre en su muro, en metros', () => {
+    const escena = normalizeHoltmontScene(leerFixture('cuarto-5x4-con-puerta'), [])
+    const nodos = Object.values(escena.nodes)
+    const muros = nodos.filter((n) => n.type === 'wall')
+    const puertas = nodos.filter((n) => n.type === 'door')
+
+    expect(muros).toHaveLength(4)
+    expect(puertas).toHaveLength(1)
+
+    const puerta = puertas[0] as Extract<(typeof nodos)[number], { type: 'door' }>
+    const muro = escena.nodes[puerta.parentId as string] as Extract<
+      (typeof nodos)[number],
+      { type: 'wall' }
+    >
+    expect(muro.type).toBe('wall')
+
+    const largo = Math.hypot(muro.end[0] - muro.start[0], muro.end[1] - muro.start[1])
+    expect(puerta.position[0]).toBeGreaterThanOrEqual(puerta.width / 2)
+    expect(puerta.position[0]).toBeLessThanOrEqual(largo - puerta.width / 2)
+    expect(puerta.position[1]).toBeCloseTo(puerta.height / 2, 6)
+    // Los valores por defecto que `setScene` no rellena y `DoorSystem` sí usa.
+    expect(puerta.segments.length).toBeGreaterThan(0)
+    expect(typeof puerta.frameThickness).toBe('number')
+  })
+
+  test('casa-dos-pisos: dos niveles, escalera con tramo y techo con tramo', () => {
+    const escena = normalizeHoltmontScene(leerFixture('casa-dos-pisos-ventanas-frente-y-atras'), [])
+    const nodos = Object.values(escena.nodes)
+    const porTipo = (tipo: string) => nodos.filter((n) => n.type === tipo)
+
+    expect(porTipo('level')).toHaveLength(2)
+    expect(porTipo('wall')).toHaveLength(8)
+    expect(porTipo('window')).toHaveLength(4)
+    expect(porTipo('stair')).toHaveLength(1)
+    expect(porTipo('stair-segment')).toHaveLength(1)
+    expect(porTipo('roof')).toHaveLength(1)
+    expect(porTipo('roof-segment')).toHaveLength(1)
+
+    // Un grupo sin tramos aparece en el árbol y no se dibuja.
+    for (const grupo of [...porTipo('stair'), ...porTipo('roof')]) {
+      expect((grupo as { children: string[] }).children.length).toBeGreaterThan(0)
+    }
+  })
+
+  test('cuarto-amueblado: el mueble del catálogo entra y el desconocido se descarta', () => {
+    const escena = normalizeHoltmontScene(leerFixture('cuarto-amueblado'), CATALOGO_DE_PRUEBA)
+    const items = Object.values(escena.nodes).filter((n) => n.type === 'item')
+
+    expect(items).toHaveLength(2)
+    for (const item of items) {
+      expect((item as { asset: { src: string } }).asset.src).toContain('.glb')
+    }
+    expect(escena.dropped.some((d) => d.reason.includes('unicornio'))).toBe(true)
+    // El nivel no puede quedarse con el id del mueble descartado colgando.
+    const nivel = Object.values(escena.nodes).find((n) => n.type === 'level') as {
+      children: string[]
+    }
+    for (const hijo of nivel.children) {
+      expect(escena.nodes[hijo]).toBeDefined()
+    }
+  })
+})
+
+describe('escenas rotas', () => {
+  function escenaBase() {
+    return JSON.parse(JSON.stringify(leerFixture('cuarto-5x4-con-puerta'))) as {
+      nodes: Record<string, Record<string, unknown>>
+      rootNodeIds: string[]
+    }
+  }
+
+  test('una puerta con position numérico se descarta en vez de tumbar el render', () => {
+    // Ésta es la forma exacta que generaba el plano 3D en negro: `DoorSystem`
+    // hacía `node.position[0]` sobre un número y reventaba dentro del useFrame.
+    const escena = escenaBase()
+    const puertaId = Object.keys(escena.nodes).find((id) => escena.nodes[id].type === 'door')!
+    escena.nodes[puertaId].position = 0.5
+
+    const resultado = normalizeHoltmontScene(escena, [])
+    expect(Object.values(resultado.nodes).some((n) => n.type === 'door')).toBe(false)
+    expect(resultado.dropped.map((d) => d.id)).toContain(puertaId)
+    // El resto de la escena sobrevive: se pierde la puerta, no el edificio.
+    expect(Object.values(resultado.nodes).filter((n) => n.type === 'wall')).toHaveLength(4)
+    // Y el muro ya no la lista, para que nadie intente dibujarla.
+    for (const nodo of Object.values(resultado.nodes)) {
+      const hijos = (nodo as { children?: unknown }).children
+      if (Array.isArray(hijos)) expect(hijos).not.toContain(puertaId)
+    }
+  })
+
+  test('un tipo que el editor no conoce se descarta con su motivo', () => {
+    const escena = escenaBase()
+    escena.nodes.staircase_viejo = {
+      object: 'node',
+      id: 'staircase_viejo',
+      type: 'staircase',
+      parentId: null,
+      visible: true,
+      metadata: {},
+    }
+    const resultado = normalizeHoltmontScene(escena, [])
+    expect(resultado.nodes.staircase_viejo).toBeUndefined()
+    expect(resultado.dropped.some((d) => d.id === 'staircase_viejo')).toBe(true)
+  })
+
+  test('un mensaje sin nodos se rechaza en vez de vaciar la escena', () => {
+    expect(() => normalizeHoltmontScene({ rootNodeIds: [] }, [])).toThrow(HoltmontImportError)
+    expect(() => normalizeHoltmontScene(null, [])).toThrow(HoltmontImportError)
+    expect(() => normalizeHoltmontScene({ nodes: {}, rootNodeIds: [] }, [])).toThrow(
+      HoltmontImportError,
+    )
+  })
+
+  test('los huérfanos del descarte se limpian en cascada', () => {
+    const escena = escenaBase()
+    const muroId = Object.keys(escena.nodes).find((id) => escena.nodes[id].type === 'wall')!
+    escena.nodes[muroId].start = 'no es un punto'
+
+    const resultado = normalizeHoltmontScene(escena, [])
+    expect(resultado.nodes[muroId]).toBeUndefined()
+    for (const nodo of Object.values(resultado.nodes)) {
+      const padre = (nodo as { parentId?: string | null }).parentId
+      if (padre) expect(resultado.nodes[padre]).toBeDefined()
+    }
+  })
+})
diff --git a/apps/editor/lib/holtmont-import.ts b/apps/editor/lib/holtmont-import.ts
new file mode 100644
index 0000000000..60a025fcbe
--- /dev/null
+++ b/apps/editor/lib/holtmont-import.ts
@@ -0,0 +1,283 @@
+/**
+ * Normalización de las escenas que Holtmont manda por `HOLTMONT_3D_IMPORT`.
+ *
+ * Por qué existe este módulo
+ * --------------------------
+ * `useScene.setScene()` no valida: guarda tal cual el objeto que recibe. Cuando
+ * el JSON del agente traía un campo con la forma equivocada — una puerta con
+ * `position: 0.5` en lugar de `position: [x, y, z]`, por ejemplo — nada fallaba
+ * en el import: el error aparecía después, dentro del `useFrame` de
+ * `DoorSystem` (`segments.reduce` sobre `undefined`), que mata el bucle de
+ * render de react-three-fiber. Resultado: el lienzo se queda negro, sin
+ * mensaje, sin traza visible para quien lo está usando.
+ *
+ * Aquí cada nodo pasa por el esquema real del editor (`AnyNode`) antes de
+ * llegar al store. Eso hace dos cosas:
+ *
+ *   1. Rellena los valores por defecto (`segments`, `frameThickness`,
+ *      `stepCount`…) que `setScene` no rellena.
+ *   2. Convierte un nodo mal formado en un descarte anotado, no en una pantalla
+ *      negra: el import sigue con el resto y el padre recibe el detalle.
+ */
+
+import { AnyNode } from '@pascal-app/core/schema'
+
+/** Lo mínimo del catálogo del editor que necesita la resolución de muebles. */
+export type CatalogAsset = {
+  id: string
+  name: string
+  [key: string]: unknown
+}
+
+export type DroppedNode = {
+  id: string
+  type: string
+  reason: string
+}
+
+export type HoltmontImportResult = {
+  nodes: Record<string, AnyNode>
+  rootNodeIds: string[]
+  collections: Record<string, unknown>
+  dropped: DroppedNode[]
+}
+
+export class HoltmontImportError extends Error {}
+
+/**
+ * Sinónimos entre el vocabulario del agente (español/inglés, singular) y los
+ * `id` del catálogo del editor. Vive aquí y no en el generador de Python
+ * porque el catálogo es del editor: si mañana cambia un `id`, cambia en un
+ * único sitio.
+ */
+const ASSET_SYNONYMS: Record<string, string[]> = {
+  'double-bed': ['bed', 'cama', 'cama matrimonial', 'double bed', 'matrimonial'],
+  'single-bed': ['single bed', 'cama individual', 'cama sencilla'],
+  bunkbed: ['bunk bed', 'litera'],
+  sofa: ['sofa', 'sofá', 'couch'],
+  'lounge-chair': ['armchair', 'sillon', 'sillón'],
+  'dining-table': ['table', 'mesa', 'dining table', 'mesa de comedor'],
+  'coffee-table': ['coffee table', 'mesa de centro'],
+  'office-table': ['desk', 'escritorio', 'office table'],
+  'dining-chair': ['chair', 'silla', 'dining chair'],
+  'office-chair': ['office chair', 'silla de oficina'],
+  stool: ['stool', 'banco', 'taburete'],
+  closet: ['wardrobe', 'closet', 'armario', 'ropero'],
+  dresser: ['dresser', 'comoda', 'cómoda'],
+  toilet: ['toilet', 'wc', 'inodoro', 'retrete'],
+  'bathroom-sink': ['sink', 'lavabo', 'lavamanos', 'bathroom sink'],
+  bathtub: ['bathtub', 'tina', 'bañera', 'banera'],
+  'shower-square': ['shower', 'regadera', 'ducha'],
+  fridge: ['refrigerator', 'fridge', 'refrigerador', 'nevera'],
+  stove: ['stove', 'estufa', 'cocina'],
+  microwave: ['microwave', 'microondas'],
+  'washing-machine': ['washing machine', 'lavadora'],
+  'kitchen-counter': ['kitchen counter', 'barra', 'cubierta de cocina'],
+  bookshelf: ['bookshelf', 'librero', 'estanteria', 'estantería'],
+  television: ['tv', 'television', 'televisión', 'televisor'],
+  'tv-stand': ['tv stand', 'mueble de tv'],
+  'indoor-plant': ['plant', 'planta', 'maceta'],
+  'rectangular-carpet': ['carpet', 'rug', 'alfombra', 'tapete'],
+}
+
+function normalizeKey(value: string): string {
+  return value
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** Índice `término normalizado → id de catálogo`, construido una vez por catálogo. */
+function buildAssetIndex(catalog: readonly CatalogAsset[]): Map<string, CatalogAsset> {
+  const byId = new Map<string, CatalogAsset>()
+  for (const asset of catalog) byId.set(asset.id, asset)
+
+  const index = new Map<string, CatalogAsset>()
+  const remember = (term: string, asset: CatalogAsset) => {
+    const key = normalizeKey(term)
+    if (key && !index.has(key)) index.set(key, asset)
+  }
+
+  // Primero los sinónimos explícitos: ganan al nombre genérico del catálogo.
+  for (const [assetId, terms] of Object.entries(ASSET_SYNONYMS)) {
+    const asset = byId.get(assetId)
+    if (!asset) continue
+    for (const term of terms) remember(term, asset)
+  }
+
+  for (const asset of catalog) {
+    remember(asset.id, asset)
+    remember(asset.name, asset)
+  }
+
+  return index
+}
+
+/**
+ * Un `item` sin `asset` no es renderizable: el `ItemRenderer` lee
+ * `node.asset.src` para cargar el GLB. El generador manda solo el nombre en
+ * `metadata.holtmontAsset` y aquí se resuelve contra el catálogo real.
+ */
+function resolveItemAsset(
+  node: Record<string, unknown>,
+  index: Map<string, CatalogAsset>,
+): Record<string, unknown> | null {
+  if (node.asset && typeof node.asset === 'object') return node
+
+  const metadata = (node.metadata ?? {}) as Record<string, unknown>
+  const wanted = metadata.holtmontAsset
+  if (typeof wanted !== 'string') return null
+
+  const key = normalizeKey(wanted)
+  const asset = index.get(key)
+  if (!asset) return null
+
+  return { ...node, asset }
+}
+
+function asPlainObject(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+/**
+ * Valida y completa la escena entrante.
+ *
+ * Lanza `HoltmontImportError` solo cuando el mensaje no es una escena en
+ * absoluto (sin `nodes`, o sin ningún nodo que sobreviva). Un lienzo negro es
+ * peor que un error: si no hay nada que dibujar, quien llama debe enterarse y
+ * dejar la escena anterior en pie.
+ */
+export function normalizeHoltmontScene(
+  projectData: unknown,
+  catalog: readonly CatalogAsset[] = [],
+): HoltmontImportResult {
+  const data = asPlainObject(projectData)
+  if (!data) throw new HoltmontImportError('projectData no es un objeto')
+
+  const rawNodes = asPlainObject(data.nodes)
+  if (!rawNodes) throw new HoltmontImportError('projectData.nodes ausente o no es un objeto')
+
+  const assetIndex = buildAssetIndex(catalog)
+  const dropped: DroppedNode[] = []
+
+  // Primera pasada: resolver los muebles contra el catálogo. Un mueble sin
+  // modelo se descarta aquí, antes de validar, para que su id no quede colgando
+  // en los `children` de su nivel: `LevelNode` valida esa lista, así que un id
+  // muerto tumbaría el nivel entero —y con él todos sus muros—.
+  const candidates: Record<string, Record<string, unknown>> = {}
+  for (const [id, rawValue] of Object.entries(rawNodes)) {
+    const raw = asPlainObject(rawValue)
+    if (!raw) {
+      dropped.push({ id, type: 'desconocido', reason: 'el nodo no es un objeto' })
+      continue
+    }
+    const type = typeof raw.type === 'string' ? raw.type : 'desconocido'
+
+    if (type === 'item') {
+      const conAsset = resolveItemAsset({ ...raw, id }, assetIndex)
+      if (!conAsset) {
+        const metadata = asPlainObject(raw.metadata) ?? {}
+        dropped.push({
+          id,
+          type,
+          reason: `sin asset en el catálogo para "${String(metadata.holtmontAsset ?? '')}"`,
+        })
+        continue
+      }
+      candidates[id] = conAsset
+      continue
+    }
+
+    candidates[id] = { ...raw, id }
+  }
+
+  pruneChildReferences(candidates)
+
+  const nodes: Record<string, AnyNode> = {}
+  for (const [id, candidate] of Object.entries(candidates)) {
+    const type = typeof candidate.type === 'string' ? candidate.type : 'desconocido'
+    const parsed = AnyNode.safeParse(candidate)
+    if (!parsed.success) {
+      dropped.push({ id, type, reason: formatZodIssues(parsed.error) })
+      continue
+    }
+    nodes[id] = parsed.data as AnyNode
+  }
+
+  pruneDanglingReferences(nodes, dropped)
+
+  const rootNodeIds = (Array.isArray(data.rootNodeIds) ? data.rootNodeIds : [])
+    .filter((id): id is string => typeof id === 'string')
+    .filter((id) => id in nodes)
+
+  if (Object.keys(nodes).length === 0) {
+    throw new HoltmontImportError(
+      `ningún nodo de la escena pasó la validación (${dropped.length} descartados)`,
+    )
+  }
+  if (rootNodeIds.length === 0) {
+    throw new HoltmontImportError('rootNodeIds vacío o apunta a nodos que no existen')
+  }
+
+  return {
+    nodes,
+    rootNodeIds,
+    collections: asPlainObject(data.collections) ?? {},
+    dropped,
+  }
+}
+
+function formatZodIssues(error: {
+  issues: Array<{ path: PropertyKey[]; message: string }>
+}): string {
+  return error.issues
+    .slice(0, 4)
+    .map((issue) => `${issue.path.join('.') || '(raíz)'}: ${issue.message}`)
+    .join('; ')
+}
+
+/**
+ * Quita referencias a nodos que no sobrevivieron y, en cascada, los nodos cuyo
+ * padre desapareció. `setScene` ya borra huérfanos, pero solo un nivel y sin
+ * limpiar los `children` del padre: un id colgado en `children` termina en
+ * `NodeRenderer` con `nodes[id] === undefined`, que es un render vacío
+ * silencioso.
+ */
+function pruneChildReferences(nodes: Record<string, { children?: unknown }>): void {
+  for (const node of Object.values(nodes)) {
+    if (!Array.isArray(node.children)) continue
+    node.children = node.children.filter((child) =>
+      typeof child === 'string' ? child in nodes : true,
+    )
+  }
+}
+
+function pruneDanglingReferences(nodes: Record<string, AnyNode>, dropped: DroppedNode[]): void {
+  let changed = true
+  while (changed) {
+    changed = false
+
+    for (const [id, node] of Object.entries(nodes)) {
+      const parentId = (node as { parentId?: string | null }).parentId
+      if (parentId && !(parentId in nodes)) {
+        delete nodes[id]
+        dropped.push({ id, type: node.type, reason: `su padre ${parentId} fue descartado` })
+        changed = true
+      }
+    }
+
+    for (const node of Object.values(nodes)) {
+      const children = (node as { children?: unknown }).children
+      if (!Array.isArray(children)) continue
+      const kept = children.filter((child) => (typeof child === 'string' ? child in nodes : true))
+      if (kept.length !== children.length) {
+        ;(node as { children: unknown[] }).children = kept
+        changed = true
+      }
+    }
+  }
+}
diff --git a/apps/editor/package.json b/apps/editor/package.json
index 518447af18..7c6c5d2479 100644
--- a/apps/editor/package.json
+++ b/apps/editor/package.json
@@ -8,7 +8,8 @@
     "build": "dotenv -e ./.env.local --override -- next build",
     "start": "next start",
     "lint": "biome lint",
-    "check-types": "next typegen && tsc --noEmit"
+    "check-types": "next typegen && tsc --noEmit",
+    "test:holtmont-smoke": "node scripts/holtmont-smoke.mjs"
   },
   "dependencies": {
     "@number-flow/react": "^0.5.14",
@@ -35,6 +36,7 @@
     "@types/react": "19.2.2",
     "@types/react-dom": "19.2.2",
     "agentation": "^2.3.2",
+    "playwright": "^1.63.0",
     "react-grab": "^0.1.25",
     "react-scan": "^0.5.3",
     "tw-animate-css": "^1.4.0",
diff --git a/apps/editor/public/holtmont-fixtures/bodega-12x8-dos-puertas-cuatro-ventanas.json b/apps/editor/public/holtmont-fixtures/bodega-12x8-dos-puertas-cuatro-ventanas.json
new file mode 100644
index 0000000000..e18c2b5052
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/bodega-12x8-dos-puertas-cuatro-ventanas.json
@@ -0,0 +1,400 @@
+{
+  "nodes": {
+    "site_3tjgwg6qop7egffs": {
+      "object": "node",
+      "id": "site_3tjgwg6qop7egffs",
+      "type": "site",
+      "name": "Site",
+      "parentId": null,
+      "visible": true,
+      "metadata": {},
+      "polygon": {
+        "type": "polygon",
+        "points": [
+          [
+            -16.0,
+            -14.0
+          ],
+          [
+            16.0,
+            -14.0
+          ],
+          [
+            16.0,
+            14.0
+          ],
+          [
+            -16.0,
+            14.0
+          ]
+        ]
+      },
+      "children": [
+        {
+          "object": "node",
+          "id": "building_pp7jltyavi9iedwk",
+          "type": "building",
+          "name": "Building",
+          "parentId": "site_3tjgwg6qop7egffs",
+          "visible": true,
+          "metadata": {},
+          "children": [
+            "level_t67yeg06wlrlb6ek"
+          ],
+          "position": [
+            0,
+            0,
+            0
+          ],
+          "rotation": [
+            0,
+            0,
+            0
+          ]
+        }
+      ]
+    },
+    "building_pp7jltyavi9iedwk": {
+      "object": "node",
+      "id": "building_pp7jltyavi9iedwk",
+      "type": "building",
+      "name": "Building",
+      "parentId": "site_3tjgwg6qop7egffs",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "level_t67yeg06wlrlb6ek"
+      ],
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "level_t67yeg06wlrlb6ek": {
+      "object": "node",
+      "id": "level_t67yeg06wlrlb6ek",
+      "type": "level",
+      "name": "Level 0",
+      "parentId": "building_pp7jltyavi9iedwk",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_4oem92dp5d9kd2dz",
+        "wall_kg3crf20zm4kvr9t",
+        "wall_gmml69dnhc1x2bri",
+        "wall_ad33ndtgbevfpgfb",
+        "slab_piksjfkqjw4wcb9c",
+        "ceiling_9imb2yyg8nrpjwas"
+      ],
+      "level": 0
+    },
+    "slab_piksjfkqjw4wcb9c": {
+      "object": "node",
+      "id": "slab_piksjfkqjw4wcb9c",
+      "type": "slab",
+      "name": "Slab L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -6.0,
+          4.0
+        ],
+        [
+          -6.0,
+          -4.0
+        ],
+        [
+          6.0,
+          -4.0
+        ],
+        [
+          6.0,
+          4.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "ceiling_9imb2yyg8nrpjwas": {
+      "object": "node",
+      "id": "ceiling_9imb2yyg8nrpjwas",
+      "type": "ceiling",
+      "name": "Ceiling L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "polygon": [
+        [
+          -6.0,
+          4.0
+        ],
+        [
+          -6.0,
+          -4.0
+        ],
+        [
+          6.0,
+          -4.0
+        ],
+        [
+          6.0,
+          4.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "height": 2.5,
+      "autoFromWalls": true
+    },
+    "wall_4oem92dp5d9kd2dz": {
+      "object": "node",
+      "id": "wall_4oem92dp5d9kd2dz",
+      "type": "wall",
+      "name": "Wall 1 L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "door_es7l3l0tdblvdagi",
+        "window_k90mr2p84gnilc0u"
+      ],
+      "start": [
+        -6.0,
+        -4.0
+      ],
+      "end": [
+        6.0,
+        -4.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_kg3crf20zm4kvr9t": {
+      "object": "node",
+      "id": "wall_kg3crf20zm4kvr9t",
+      "type": "wall",
+      "name": "Wall 2 L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_9nhav2okvrmwykez"
+      ],
+      "start": [
+        6.0,
+        -4.0
+      ],
+      "end": [
+        6.0,
+        4.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_gmml69dnhc1x2bri": {
+      "object": "node",
+      "id": "wall_gmml69dnhc1x2bri",
+      "type": "wall",
+      "name": "Wall 3 L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "door_ovf259sljwxxfp3l",
+        "window_4kzme62f7vnp6v39"
+      ],
+      "start": [
+        6.0,
+        4.0
+      ],
+      "end": [
+        -6.0,
+        4.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_ad33ndtgbevfpgfb": {
+      "object": "node",
+      "id": "wall_ad33ndtgbevfpgfb",
+      "type": "wall",
+      "name": "Wall 4 L0",
+      "parentId": "level_t67yeg06wlrlb6ek",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_1b95agg4a375u2xm"
+      ],
+      "start": [
+        -6.0,
+        4.0
+      ],
+      "end": [
+        -6.0,
+        -4.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "door_es7l3l0tdblvdagi": {
+      "object": "node",
+      "id": "door_es7l3l0tdblvdagi",
+      "type": "door",
+      "name": "Door 1",
+      "parentId": "wall_4oem92dp5d9kd2dz",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_4oem92dp5d9kd2dz",
+      "side": "front",
+      "position": [
+        6.0,
+        1.05,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 0.9,
+      "height": 2.1
+    },
+    "door_ovf259sljwxxfp3l": {
+      "object": "node",
+      "id": "door_ovf259sljwxxfp3l",
+      "type": "door",
+      "name": "Door 2",
+      "parentId": "wall_gmml69dnhc1x2bri",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_gmml69dnhc1x2bri",
+      "side": "front",
+      "position": [
+        6.0,
+        1.05,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 0.9,
+      "height": 2.1
+    },
+    "window_9nhav2okvrmwykez": {
+      "object": "node",
+      "id": "window_9nhav2okvrmwykez",
+      "type": "window",
+      "name": "Window 1",
+      "parentId": "wall_kg3crf20zm4kvr9t",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_kg3crf20zm4kvr9t",
+      "side": "front",
+      "position": [
+        4.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_1b95agg4a375u2xm": {
+      "object": "node",
+      "id": "window_1b95agg4a375u2xm",
+      "type": "window",
+      "name": "Window 2",
+      "parentId": "wall_ad33ndtgbevfpgfb",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_ad33ndtgbevfpgfb",
+      "side": "front",
+      "position": [
+        4.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_k90mr2p84gnilc0u": {
+      "object": "node",
+      "id": "window_k90mr2p84gnilc0u",
+      "type": "window",
+      "name": "Window 3",
+      "parentId": "wall_4oem92dp5d9kd2dz",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_4oem92dp5d9kd2dz",
+      "side": "front",
+      "position": [
+        3.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_4kzme62f7vnp6v39": {
+      "object": "node",
+      "id": "window_4kzme62f7vnp6v39",
+      "type": "window",
+      "name": "Window 4",
+      "parentId": "wall_gmml69dnhc1x2bri",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_gmml69dnhc1x2bri",
+      "side": "front",
+      "position": [
+        3.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    }
+  },
+  "rootNodeIds": [
+    "site_3tjgwg6qop7egffs"
+  ]
+}
diff --git a/apps/editor/public/holtmont-fixtures/casa-dos-pisos-ventanas-frente-y-atras.json b/apps/editor/public/holtmont-fixtures/casa-dos-pisos-ventanas-frente-y-atras.json
new file mode 100644
index 0000000000..9515048bc3
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/casa-dos-pisos-ventanas-frente-y-atras.json
@@ -0,0 +1,601 @@
+{
+  "nodes": {
+    "site_yfkh63jdjdrna1sw": {
+      "object": "node",
+      "id": "site_yfkh63jdjdrna1sw",
+      "type": "site",
+      "name": "Site",
+      "parentId": null,
+      "visible": true,
+      "metadata": {},
+      "polygon": {
+        "type": "polygon",
+        "points": [
+          [
+            -14.0,
+            -13.0
+          ],
+          [
+            14.0,
+            -13.0
+          ],
+          [
+            14.0,
+            13.0
+          ],
+          [
+            -14.0,
+            13.0
+          ]
+        ]
+      },
+      "children": [
+        {
+          "object": "node",
+          "id": "building_im7fmhvtepnlv0jy",
+          "type": "building",
+          "name": "Building",
+          "parentId": "site_yfkh63jdjdrna1sw",
+          "visible": true,
+          "metadata": {},
+          "children": [
+            "level_ul5v646s1ujoynoe",
+            "level_1430d9c46ybg24lr"
+          ],
+          "position": [
+            0,
+            0,
+            0
+          ],
+          "rotation": [
+            0,
+            0,
+            0
+          ]
+        }
+      ]
+    },
+    "building_im7fmhvtepnlv0jy": {
+      "object": "node",
+      "id": "building_im7fmhvtepnlv0jy",
+      "type": "building",
+      "name": "Building",
+      "parentId": "site_yfkh63jdjdrna1sw",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "level_ul5v646s1ujoynoe",
+        "level_1430d9c46ybg24lr"
+      ],
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "level_ul5v646s1ujoynoe": {
+      "object": "node",
+      "id": "level_ul5v646s1ujoynoe",
+      "type": "level",
+      "name": "Level 0",
+      "parentId": "building_im7fmhvtepnlv0jy",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_y5f4epk9hgqnswea",
+        "wall_lln6ktpq56j556mm",
+        "wall_z1eh5rkcadv26ofe",
+        "wall_l1zzoxoybdl5kpvf",
+        "slab_ykndbmkyrx75fwxr",
+        "ceiling_mzgka7qlak9ysmn6",
+        "stair_9sivobrm4lr4iglk"
+      ],
+      "level": 0
+    },
+    "level_1430d9c46ybg24lr": {
+      "object": "node",
+      "id": "level_1430d9c46ybg24lr",
+      "type": "level",
+      "name": "Level 1",
+      "parentId": "building_im7fmhvtepnlv0jy",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_0mhg1xrhyx4ceki6",
+        "wall_c2bnp4jjg37v1emg",
+        "wall_xc9o9grpgd6ken34",
+        "wall_gcfesaliergex08m",
+        "slab_u4kj4l2vud9z1uex",
+        "roof_tp32bei17eb95aph"
+      ],
+      "level": 1
+    },
+    "slab_ykndbmkyrx75fwxr": {
+      "object": "node",
+      "id": "slab_ykndbmkyrx75fwxr",
+      "type": "slab",
+      "name": "Slab L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -4.0,
+          3.0
+        ],
+        [
+          -4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          3.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "ceiling_mzgka7qlak9ysmn6": {
+      "object": "node",
+      "id": "ceiling_mzgka7qlak9ysmn6",
+      "type": "ceiling",
+      "name": "Ceiling L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "polygon": [
+        [
+          -4.0,
+          3.0
+        ],
+        [
+          -4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          3.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "height": 2.7,
+      "autoFromWalls": true
+    },
+    "slab_u4kj4l2vud9z1uex": {
+      "object": "node",
+      "id": "slab_u4kj4l2vud9z1uex",
+      "type": "slab",
+      "name": "Slab L1",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -4.0,
+          3.0
+        ],
+        [
+          -4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          -3.0
+        ],
+        [
+          4.0,
+          3.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "roof_tp32bei17eb95aph": {
+      "object": "node",
+      "id": "roof_tp32bei17eb95aph",
+      "type": "roof",
+      "name": "Main Roof",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "rseg_4yw51hvic8u68djd"
+      ],
+      "position": [
+        0.0,
+        2.5,
+        0.0
+      ],
+      "rotation": 0.0
+    },
+    "rseg_4yw51hvic8u68djd": {
+      "object": "node",
+      "id": "rseg_4yw51hvic8u68djd",
+      "type": "roof-segment",
+      "name": "Roof Segment 1",
+      "parentId": "roof_tp32bei17eb95aph",
+      "visible": true,
+      "metadata": {},
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": 0,
+      "roofType": "gable",
+      "width": 8.0,
+      "depth": 6.0,
+      "wallHeight": 0.2,
+      "roofHeight": 1.7320508075688772,
+      "overhang": 0.5
+    },
+    "wall_y5f4epk9hgqnswea": {
+      "object": "node",
+      "id": "wall_y5f4epk9hgqnswea",
+      "type": "wall",
+      "name": "Wall 1 L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "door_zu158j7pyq805obk",
+        "window_arop7bx2snqj713g"
+      ],
+      "start": [
+        -4.0,
+        -3.0
+      ],
+      "end": [
+        4.0,
+        -3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_lln6ktpq56j556mm": {
+      "object": "node",
+      "id": "wall_lln6ktpq56j556mm",
+      "type": "wall",
+      "name": "Wall 2 L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        4.0,
+        -3.0
+      ],
+      "end": [
+        4.0,
+        3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_z1eh5rkcadv26ofe": {
+      "object": "node",
+      "id": "wall_z1eh5rkcadv26ofe",
+      "type": "wall",
+      "name": "Wall 3 L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_o9u5ni0iyf4hxary"
+      ],
+      "start": [
+        4.0,
+        3.0
+      ],
+      "end": [
+        -4.0,
+        3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_l1zzoxoybdl5kpvf": {
+      "object": "node",
+      "id": "wall_l1zzoxoybdl5kpvf",
+      "type": "wall",
+      "name": "Wall 4 L0",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -4.0,
+        3.0
+      ],
+      "end": [
+        -4.0,
+        -3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_0mhg1xrhyx4ceki6": {
+      "object": "node",
+      "id": "wall_0mhg1xrhyx4ceki6",
+      "type": "wall",
+      "name": "Wall 5 L1",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_3o3glp1h57kuqndv"
+      ],
+      "start": [
+        -4.0,
+        -3.0
+      ],
+      "end": [
+        4.0,
+        -3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_c2bnp4jjg37v1emg": {
+      "object": "node",
+      "id": "wall_c2bnp4jjg37v1emg",
+      "type": "wall",
+      "name": "Wall 6 L1",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        4.0,
+        -3.0
+      ],
+      "end": [
+        4.0,
+        3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_xc9o9grpgd6ken34": {
+      "object": "node",
+      "id": "wall_xc9o9grpgd6ken34",
+      "type": "wall",
+      "name": "Wall 7 L1",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_45rrf9ovv2hzfgpp"
+      ],
+      "start": [
+        4.0,
+        3.0
+      ],
+      "end": [
+        -4.0,
+        3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_gcfesaliergex08m": {
+      "object": "node",
+      "id": "wall_gcfesaliergex08m",
+      "type": "wall",
+      "name": "Wall 8 L1",
+      "parentId": "level_1430d9c46ybg24lr",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -4.0,
+        3.0
+      ],
+      "end": [
+        -4.0,
+        -3.0
+      ],
+      "thickness": 0.2,
+      "height": 2.7,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "door_zu158j7pyq805obk": {
+      "object": "node",
+      "id": "door_zu158j7pyq805obk",
+      "type": "door",
+      "name": "Door 1",
+      "parentId": "wall_y5f4epk9hgqnswea",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_y5f4epk9hgqnswea",
+      "side": "front",
+      "position": [
+        2.0,
+        1.05,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 0.9,
+      "height": 2.1
+    },
+    "window_arop7bx2snqj713g": {
+      "object": "node",
+      "id": "window_arop7bx2snqj713g",
+      "type": "window",
+      "name": "Window 1",
+      "parentId": "wall_y5f4epk9hgqnswea",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_y5f4epk9hgqnswea",
+      "side": "front",
+      "position": [
+        4.8,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_o9u5ni0iyf4hxary": {
+      "object": "node",
+      "id": "window_o9u5ni0iyf4hxary",
+      "type": "window",
+      "name": "Window 2",
+      "parentId": "wall_z1eh5rkcadv26ofe",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_z1eh5rkcadv26ofe",
+      "side": "front",
+      "position": [
+        4.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_3o3glp1h57kuqndv": {
+      "object": "node",
+      "id": "window_3o3glp1h57kuqndv",
+      "type": "window",
+      "name": "Window 3",
+      "parentId": "wall_0mhg1xrhyx4ceki6",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_0mhg1xrhyx4ceki6",
+      "side": "front",
+      "position": [
+        4.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "window_45rrf9ovv2hzfgpp": {
+      "object": "node",
+      "id": "window_45rrf9ovv2hzfgpp",
+      "type": "window",
+      "name": "Window 4",
+      "parentId": "wall_xc9o9grpgd6ken34",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_xc9o9grpgd6ken34",
+      "side": "front",
+      "position": [
+        4.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "stair_9sivobrm4lr4iglk": {
+      "object": "node",
+      "id": "stair_9sivobrm4lr4iglk",
+      "type": "stair",
+      "name": "Staircase 1",
+      "parentId": "level_ul5v646s1ujoynoe",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "sseg_9tnctgvyk3ie28a9"
+      ],
+      "position": [
+        2.5,
+        0,
+        0.0
+      ],
+      "rotation": 0.0,
+      "stairType": "straight",
+      "fromLevelId": "level_ul5v646s1ujoynoe",
+      "toLevelId": "level_1430d9c46ybg24lr",
+      "slabOpeningMode": "destination",
+      "width": 1.0,
+      "totalRise": 2.7,
+      "stepCount": 10
+    },
+    "sseg_9tnctgvyk3ie28a9": {
+      "object": "node",
+      "id": "sseg_9tnctgvyk3ie28a9",
+      "type": "stair-segment",
+      "name": "Staircase 1 — tramo 1",
+      "parentId": "stair_9sivobrm4lr4iglk",
+      "visible": true,
+      "metadata": {},
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": 0,
+      "segmentType": "stair",
+      "width": 1.0,
+      "length": 2.8000000000000003,
+      "height": 2.7,
+      "stepCount": 10,
+      "attachmentSide": "front"
+    }
+  },
+  "rootNodeIds": [
+    "site_yfkh63jdjdrna1sw"
+  ]
+}
diff --git a/apps/editor/public/holtmont-fixtures/cuarto-5x4-con-puerta.json b/apps/editor/public/holtmont-fixtures/cuarto-5x4-con-puerta.json
new file mode 100644
index 0000000000..861875d457
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/cuarto-5x4-con-puerta.json
@@ -0,0 +1,277 @@
+{
+  "nodes": {
+    "site_1dzj1tfcs2m51ne4": {
+      "object": "node",
+      "id": "site_1dzj1tfcs2m51ne4",
+      "type": "site",
+      "name": "Site",
+      "parentId": null,
+      "visible": true,
+      "metadata": {},
+      "polygon": {
+        "type": "polygon",
+        "points": [
+          [
+            -12.5,
+            -12.0
+          ],
+          [
+            12.5,
+            -12.0
+          ],
+          [
+            12.5,
+            12.0
+          ],
+          [
+            -12.5,
+            12.0
+          ]
+        ]
+      },
+      "children": [
+        {
+          "object": "node",
+          "id": "building_yg5kunim1ok683bi",
+          "type": "building",
+          "name": "Building",
+          "parentId": "site_1dzj1tfcs2m51ne4",
+          "visible": true,
+          "metadata": {},
+          "children": [
+            "level_4qncuxa9vub9s6l0"
+          ],
+          "position": [
+            0,
+            0,
+            0
+          ],
+          "rotation": [
+            0,
+            0,
+            0
+          ]
+        }
+      ]
+    },
+    "building_yg5kunim1ok683bi": {
+      "object": "node",
+      "id": "building_yg5kunim1ok683bi",
+      "type": "building",
+      "name": "Building",
+      "parentId": "site_1dzj1tfcs2m51ne4",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "level_4qncuxa9vub9s6l0"
+      ],
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "level_4qncuxa9vub9s6l0": {
+      "object": "node",
+      "id": "level_4qncuxa9vub9s6l0",
+      "type": "level",
+      "name": "Level 0",
+      "parentId": "building_yg5kunim1ok683bi",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_c0a2d84nwg75nzpa",
+        "wall_s8b4nhp6pw2cnv6m",
+        "wall_jfplzjbul5ao3vkh",
+        "wall_5qhk2n8omamm1ki9",
+        "slab_rti45jb4vk0wvmww",
+        "ceiling_x1y6h80czrsl9rk3"
+      ],
+      "level": 0
+    },
+    "slab_rti45jb4vk0wvmww": {
+      "object": "node",
+      "id": "slab_rti45jb4vk0wvmww",
+      "type": "slab",
+      "name": "Slab L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -2.5,
+          2.0
+        ],
+        [
+          -2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          2.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "ceiling_x1y6h80czrsl9rk3": {
+      "object": "node",
+      "id": "ceiling_x1y6h80czrsl9rk3",
+      "type": "ceiling",
+      "name": "Ceiling L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "polygon": [
+        [
+          -2.5,
+          2.0
+        ],
+        [
+          -2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          2.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "height": 2.5,
+      "autoFromWalls": true
+    },
+    "wall_c0a2d84nwg75nzpa": {
+      "object": "node",
+      "id": "wall_c0a2d84nwg75nzpa",
+      "type": "wall",
+      "name": "Wall 1 L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "door_t6bgjb66oi5xppp3"
+      ],
+      "start": [
+        -2.5,
+        -2.0
+      ],
+      "end": [
+        2.5,
+        -2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_s8b4nhp6pw2cnv6m": {
+      "object": "node",
+      "id": "wall_s8b4nhp6pw2cnv6m",
+      "type": "wall",
+      "name": "Wall 2 L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        2.5,
+        -2.0
+      ],
+      "end": [
+        2.5,
+        2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_jfplzjbul5ao3vkh": {
+      "object": "node",
+      "id": "wall_jfplzjbul5ao3vkh",
+      "type": "wall",
+      "name": "Wall 3 L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        2.5,
+        2.0
+      ],
+      "end": [
+        -2.5,
+        2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_5qhk2n8omamm1ki9": {
+      "object": "node",
+      "id": "wall_5qhk2n8omamm1ki9",
+      "type": "wall",
+      "name": "Wall 4 L0",
+      "parentId": "level_4qncuxa9vub9s6l0",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -2.5,
+        2.0
+      ],
+      "end": [
+        -2.5,
+        -2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "door_t6bgjb66oi5xppp3": {
+      "object": "node",
+      "id": "door_t6bgjb66oi5xppp3",
+      "type": "door",
+      "name": "Door 1",
+      "parentId": "wall_c0a2d84nwg75nzpa",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_c0a2d84nwg75nzpa",
+      "side": "front",
+      "position": [
+        2.5,
+        1.05,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 0.9,
+      "height": 2.1
+    }
+  },
+  "rootNodeIds": [
+    "site_1dzj1tfcs2m51ne4"
+  ]
+}
diff --git a/apps/editor/public/holtmont-fixtures/cuarto-amueblado.json b/apps/editor/public/holtmont-fixtures/cuarto-amueblado.json
new file mode 100644
index 0000000000..fbdad89f01
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/cuarto-amueblado.json
@@ -0,0 +1,386 @@
+{
+  "nodes": {
+    "site_5z9zytt6atfot6la": {
+      "object": "node",
+      "id": "site_5z9zytt6atfot6la",
+      "type": "site",
+      "name": "Site",
+      "parentId": null,
+      "visible": true,
+      "metadata": {},
+      "polygon": {
+        "type": "polygon",
+        "points": [
+          [
+            -12.5,
+            -12.0
+          ],
+          [
+            12.5,
+            -12.0
+          ],
+          [
+            12.5,
+            12.0
+          ],
+          [
+            -12.5,
+            12.0
+          ]
+        ]
+      },
+      "children": [
+        {
+          "object": "node",
+          "id": "building_k3l4w0vcr4zqidrh",
+          "type": "building",
+          "name": "Building",
+          "parentId": "site_5z9zytt6atfot6la",
+          "visible": true,
+          "metadata": {},
+          "children": [
+            "level_34uz1g9cges4ppmw"
+          ],
+          "position": [
+            0,
+            0,
+            0
+          ],
+          "rotation": [
+            0,
+            0,
+            0
+          ]
+        }
+      ]
+    },
+    "building_k3l4w0vcr4zqidrh": {
+      "object": "node",
+      "id": "building_k3l4w0vcr4zqidrh",
+      "type": "building",
+      "name": "Building",
+      "parentId": "site_5z9zytt6atfot6la",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "level_34uz1g9cges4ppmw"
+      ],
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "level_34uz1g9cges4ppmw": {
+      "object": "node",
+      "id": "level_34uz1g9cges4ppmw",
+      "type": "level",
+      "name": "Level 0",
+      "parentId": "building_k3l4w0vcr4zqidrh",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_xtbyginofxjztalq",
+        "wall_amp30lwjox82w8yd",
+        "wall_cnpxsmb7ghe3jwob",
+        "wall_66d7rvi5o5vm9nh0",
+        "slab_clcymucwcux3jvx9",
+        "ceiling_x9e02bm89gegyrcg",
+        "item_riw5vzhwggj78seg",
+        "item_5rqsv35swrhzg8sx",
+        "item_aykebffn6xhvv2pn"
+      ],
+      "level": 0
+    },
+    "slab_clcymucwcux3jvx9": {
+      "object": "node",
+      "id": "slab_clcymucwcux3jvx9",
+      "type": "slab",
+      "name": "Slab L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -2.5,
+          2.0
+        ],
+        [
+          -2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          2.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "ceiling_x9e02bm89gegyrcg": {
+      "object": "node",
+      "id": "ceiling_x9e02bm89gegyrcg",
+      "type": "ceiling",
+      "name": "Ceiling L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "polygon": [
+        [
+          -2.5,
+          2.0
+        ],
+        [
+          -2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          -2.0
+        ],
+        [
+          2.5,
+          2.0
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "height": 2.5,
+      "autoFromWalls": true
+    },
+    "wall_xtbyginofxjztalq": {
+      "object": "node",
+      "id": "wall_xtbyginofxjztalq",
+      "type": "wall",
+      "name": "Wall 1 L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "door_yws4t6inzfaqci75"
+      ],
+      "start": [
+        -2.5,
+        -2.0
+      ],
+      "end": [
+        2.5,
+        -2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_amp30lwjox82w8yd": {
+      "object": "node",
+      "id": "wall_amp30lwjox82w8yd",
+      "type": "wall",
+      "name": "Wall 2 L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "window_xd92gwo37dgl3roo"
+      ],
+      "start": [
+        2.5,
+        -2.0
+      ],
+      "end": [
+        2.5,
+        2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_cnpxsmb7ghe3jwob": {
+      "object": "node",
+      "id": "wall_cnpxsmb7ghe3jwob",
+      "type": "wall",
+      "name": "Wall 3 L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        2.5,
+        2.0
+      ],
+      "end": [
+        -2.5,
+        2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_66d7rvi5o5vm9nh0": {
+      "object": "node",
+      "id": "wall_66d7rvi5o5vm9nh0",
+      "type": "wall",
+      "name": "Wall 4 L0",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -2.5,
+        2.0
+      ],
+      "end": [
+        -2.5,
+        -2.0
+      ],
+      "thickness": 0.2,
+      "height": 2.5,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "door_yws4t6inzfaqci75": {
+      "object": "node",
+      "id": "door_yws4t6inzfaqci75",
+      "type": "door",
+      "name": "Door 1",
+      "parentId": "wall_xtbyginofxjztalq",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_xtbyginofxjztalq",
+      "side": "front",
+      "position": [
+        2.5,
+        1.05,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 0.9,
+      "height": 2.1
+    },
+    "window_xd92gwo37dgl3roo": {
+      "object": "node",
+      "id": "window_xd92gwo37dgl3roo",
+      "type": "window",
+      "name": "Window 1",
+      "parentId": "wall_amp30lwjox82w8yd",
+      "visible": true,
+      "metadata": {},
+      "wallId": "wall_amp30lwjox82w8yd",
+      "side": "front",
+      "position": [
+        2.0,
+        1.4,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ],
+      "width": 1.2,
+      "height": 1.0
+    },
+    "item_riw5vzhwggj78seg": {
+      "object": "node",
+      "id": "item_riw5vzhwggj78seg",
+      "type": "item",
+      "name": "cama",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {
+        "holtmontAsset": "cama"
+      },
+      "children": [],
+      "position": [
+        -1.0,
+        0,
+        1.0
+      ],
+      "rotation": [
+        0,
+        1.5707963267948966,
+        0
+      ],
+      "scale": [
+        1,
+        1,
+        1
+      ]
+    },
+    "item_5rqsv35swrhzg8sx": {
+      "object": "node",
+      "id": "item_5rqsv35swrhzg8sx",
+      "type": "item",
+      "name": "escritorio",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {
+        "holtmontAsset": "escritorio"
+      },
+      "children": [],
+      "position": [
+        1.5,
+        0,
+        -1.0
+      ],
+      "rotation": [
+        0,
+        0.0,
+        0
+      ],
+      "scale": [
+        1,
+        1,
+        1
+      ]
+    },
+    "item_aykebffn6xhvv2pn": {
+      "object": "node",
+      "id": "item_aykebffn6xhvv2pn",
+      "type": "item",
+      "name": "unicornio",
+      "parentId": "level_34uz1g9cges4ppmw",
+      "visible": true,
+      "metadata": {
+        "holtmontAsset": "unicornio"
+      },
+      "children": [],
+      "position": [
+        0.0,
+        0,
+        0.0
+      ],
+      "rotation": [
+        0,
+        0.0,
+        0
+      ],
+      "scale": [
+        1,
+        1,
+        1
+      ]
+    }
+  },
+  "rootNodeIds": [
+    "site_5z9zytt6atfot6la"
+  ]
+}
diff --git a/apps/editor/public/holtmont-fixtures/index.json b/apps/editor/public/holtmont-fixtures/index.json
new file mode 100644
index 0000000000..6c9f0779cd
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/index.json
@@ -0,0 +1,7 @@
+[
+  "bodega-12x8-dos-puertas-cuatro-ventanas",
+  "casa-dos-pisos-ventanas-frente-y-atras",
+  "cuarto-5x4-con-puerta",
+  "cuarto-amueblado",
+  "oficina-sin-vanos"
+]
diff --git a/apps/editor/public/holtmont-fixtures/oficina-sin-vanos.json b/apps/editor/public/holtmont-fixtures/oficina-sin-vanos.json
new file mode 100644
index 0000000000..730aaed403
--- /dev/null
+++ b/apps/editor/public/holtmont-fixtures/oficina-sin-vanos.json
@@ -0,0 +1,252 @@
+{
+  "nodes": {
+    "site_44vcklchxrsu493m": {
+      "object": "node",
+      "id": "site_44vcklchxrsu493m",
+      "type": "site",
+      "name": "Site",
+      "parentId": null,
+      "visible": true,
+      "metadata": {},
+      "polygon": {
+        "type": "polygon",
+        "points": [
+          [
+            -11.75,
+            -11.25
+          ],
+          [
+            11.75,
+            -11.25
+          ],
+          [
+            11.75,
+            11.25
+          ],
+          [
+            -11.75,
+            11.25
+          ]
+        ]
+      },
+      "children": [
+        {
+          "object": "node",
+          "id": "building_mhn41ry4ifmak1n0",
+          "type": "building",
+          "name": "Building",
+          "parentId": "site_44vcklchxrsu493m",
+          "visible": true,
+          "metadata": {},
+          "children": [
+            "level_pqr73vun3wdwykxf"
+          ],
+          "position": [
+            0,
+            0,
+            0
+          ],
+          "rotation": [
+            0,
+            0,
+            0
+          ]
+        }
+      ]
+    },
+    "building_mhn41ry4ifmak1n0": {
+      "object": "node",
+      "id": "building_mhn41ry4ifmak1n0",
+      "type": "building",
+      "name": "Building",
+      "parentId": "site_44vcklchxrsu493m",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "level_pqr73vun3wdwykxf"
+      ],
+      "position": [
+        0,
+        0,
+        0
+      ],
+      "rotation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "level_pqr73vun3wdwykxf": {
+      "object": "node",
+      "id": "level_pqr73vun3wdwykxf",
+      "type": "level",
+      "name": "Level 0",
+      "parentId": "building_mhn41ry4ifmak1n0",
+      "visible": true,
+      "metadata": {},
+      "children": [
+        "wall_3eqvbpi77icsuu1l",
+        "wall_bqhs6hovleesjn79",
+        "wall_5dztd1aefv8uturq",
+        "wall_3yu8ktpnwjqtrdhi",
+        "slab_d8wytuq2emnfrmaz",
+        "ceiling_3nyhgoh52jxz3vni"
+      ],
+      "level": 0
+    },
+    "slab_d8wytuq2emnfrmaz": {
+      "object": "node",
+      "id": "slab_d8wytuq2emnfrmaz",
+      "type": "slab",
+      "name": "Slab L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "polygon": [
+        [
+          -1.75,
+          1.25
+        ],
+        [
+          -1.75,
+          -1.25
+        ],
+        [
+          1.75,
+          -1.25
+        ],
+        [
+          1.75,
+          1.25
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "elevation": 0.05,
+      "autoFromWalls": true
+    },
+    "ceiling_3nyhgoh52jxz3vni": {
+      "object": "node",
+      "id": "ceiling_3nyhgoh52jxz3vni",
+      "type": "ceiling",
+      "name": "Ceiling L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "polygon": [
+        [
+          -1.75,
+          1.25
+        ],
+        [
+          -1.75,
+          -1.25
+        ],
+        [
+          1.75,
+          -1.25
+        ],
+        [
+          1.75,
+          1.25
+        ]
+      ],
+      "holes": [],
+      "holeMetadata": [],
+      "height": 3.0,
+      "autoFromWalls": true
+    },
+    "wall_3eqvbpi77icsuu1l": {
+      "object": "node",
+      "id": "wall_3eqvbpi77icsuu1l",
+      "type": "wall",
+      "name": "Wall 1 L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -1.75,
+        -1.25
+      ],
+      "end": [
+        1.75,
+        -1.25
+      ],
+      "thickness": 0.2,
+      "height": 3.0,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_bqhs6hovleesjn79": {
+      "object": "node",
+      "id": "wall_bqhs6hovleesjn79",
+      "type": "wall",
+      "name": "Wall 2 L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        1.75,
+        -1.25
+      ],
+      "end": [
+        1.75,
+        1.25
+      ],
+      "thickness": 0.2,
+      "height": 3.0,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_5dztd1aefv8uturq": {
+      "object": "node",
+      "id": "wall_5dztd1aefv8uturq",
+      "type": "wall",
+      "name": "Wall 3 L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        1.75,
+        1.25
+      ],
+      "end": [
+        -1.75,
+        1.25
+      ],
+      "thickness": 0.2,
+      "height": 3.0,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    },
+    "wall_3yu8ktpnwjqtrdhi": {
+      "object": "node",
+      "id": "wall_3yu8ktpnwjqtrdhi",
+      "type": "wall",
+      "name": "Wall 4 L0",
+      "parentId": "level_pqr73vun3wdwykxf",
+      "visible": true,
+      "metadata": {},
+      "children": [],
+      "start": [
+        -1.75,
+        1.25
+      ],
+      "end": [
+        -1.75,
+        -1.25
+      ],
+      "thickness": 0.2,
+      "height": 3.0,
+      "frontSide": "exterior",
+      "backSide": "interior"
+    }
+  },
+  "rootNodeIds": [
+    "site_44vcklchxrsu493m"
+  ]
+}
diff --git a/apps/editor/scripts/holtmont-smoke.mjs b/apps/editor/scripts/holtmont-smoke.mjs
new file mode 100644
index 0000000000..a6fcc1c5b0
--- /dev/null
+++ b/apps/editor/scripts/holtmont-smoke.mjs
@@ -0,0 +1,183 @@
+/**
+ * Prueba de humo del plano 3D: abre el editor de verdad en un navegador,
+ * le manda cada escena del agente por `postMessage` y comprueba que la
+ * geometría existe en la escena, no solo en el store.
+ *
+ * Es la prueba que faltaba. El bug que arregla —el lienzo negro— no rompía
+ * ningún import: `setScene` guardaba la escena sin quejarse y el fallo ocurría
+ * después, dentro del `useFrame` de `DoorSystem`, matando el bucle de render.
+ * Contra el store todo parecía correcto; solo mirando la geometría dibujada se
+ * ve la diferencia.
+ *
+ *   bun run --cwd apps/editor dev        # en otra terminal (o usa --start)
+ *   node apps/editor/scripts/holtmont-smoke.mjs
+ *
+ * Opciones:
+ *   --base-url=http://localhost:3002   dónde escucha el editor
+ *   --scene=<nombre>                   solo esa escena
+ *   --screenshots=<directorio>         guarda una captura por escena
+ *   --executable=<ruta>                Chromium a usar (o PLAYWRIGHT_CHROMIUM_EXECUTABLE),
+ *                                      para entornos con el navegador ya instalado aparte
+ */
+
+import { mkdirSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { chromium } from 'playwright'
+
+const AQUI = dirname(fileURLToPath(import.meta.url))
+const FIXTURES = resolve(AQUI, '..', 'public', 'holtmont-fixtures')
+
+const opciones = Object.fromEntries(
+  process.argv
+    .slice(2)
+    .filter((a) => a.startsWith('--'))
+    .map((a) => {
+      const [clave, ...resto] = a.slice(2).split('=')
+      return [clave, resto.join('=') || 'true']
+    }),
+)
+
+const BASE_URL = opciones['base-url'] ?? 'http://localhost:3002'
+const CAPTURAS = opciones.screenshots ? resolve(opciones.screenshots) : null
+
+// Lo que cada escena tiene que llegar a dibujar. Los números salen del propio
+// generador: un cuarto tiene cuatro muros, una casa de dos pisos ocho.
+const ESPERADO = {
+  'cuarto-5x4-con-puerta': { wall: 4, door: 1, slab: 1, ceiling: 1 },
+  'bodega-12x8-dos-puertas-cuatro-ventanas': { wall: 4, door: 2, window: 4, slab: 1 },
+  'oficina-sin-vanos': { wall: 4, slab: 1, ceiling: 1 },
+  'casa-dos-pisos-ventanas-frente-y-atras': {
+    wall: 8,
+    window: 4,
+    door: 1,
+    slab: 2,
+    stair: 1,
+    roof: 1,
+  },
+  'cuarto-amueblado': { wall: 4, door: 1, window: 1, item: 2 },
+}
+
+const escenas = JSON.parse(readFileSync(join(FIXTURES, 'index.json'), 'utf-8')).filter(
+  (nombre) => !opciones.scene || opciones.scene === nombre,
+)
+
+if (escenas.length === 0) {
+  console.error(`No hay ninguna escena que coincida con --scene=${opciones.scene}`)
+  process.exit(1)
+}
+
+if (CAPTURAS) mkdirSync(CAPTURAS, { recursive: true })
+
+const EJECUTABLE = opciones.executable ?? process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE
+
+const navegador = await chromium.launch({
+  ...(EJECUTABLE ? { executablePath: EJECUTABLE } : {}),
+  args: ['--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'],
+})
+
+let fallos = 0
+
+for (const escena of escenas) {
+  const contexto = await navegador.newContext({ viewport: { width: 1400, height: 900 } })
+  const pagina = await contexto.newPage()
+  // Solo interesan los errores de código: una excepción dentro de un `useFrame`
+  // mata el bucle de render de react-three-fiber sin decir nada, y eso es lo
+  // que dejaba el plano en negro. El ruido de red del servidor de desarrollo
+  // (HMR, favicons) no dice nada del dibujo.
+  const RUIDO_DE_RED =
+    /Failed to load resource|ERR_CONNECTION|ERR_ABORTED|favicon|^Event$|blocked by CORS policy|unpkg\.com|react-scan/
+  const erroresDeConsola = []
+  pagina.on('pageerror', (err) => erroresDeConsola.push(`excepción: ${err}`))
+  pagina.on('console', (msg) => {
+    if (msg.type() !== 'error') return
+    const texto = msg.text().trim()
+    if (!RUIDO_DE_RED.test(texto)) erroresDeConsola.push(texto)
+  })
+
+  try {
+    await pagina.goto(`${BASE_URL}/test-holtmont?scene=${escena}`, {
+      waitUntil: 'domcontentloaded',
+      timeout: 120_000,
+    })
+
+    // El banco de pruebas envía la escena en cuanto el editor manda PASCAL_READY.
+    await pagina.waitForFunction(
+      () => window.__holtmontTest?.ack || window.__holtmontTest?.error,
+      null,
+      { timeout: 120_000 },
+    )
+
+    const estado = await pagina.evaluate(() => window.__holtmontTest)
+    if (estado.error) {
+      throw new Error(`el puente rechazó la escena: ${estado.error.reason}`)
+    }
+
+    const descartesRaros = (estado.ack.dropped ?? []).filter(
+      (d) => !String(d.reason).startsWith('sin asset'),
+    )
+    if (descartesRaros.length > 0) {
+      throw new Error(`nodos descartados: ${JSON.stringify(descartesRaros)}`)
+    }
+
+    // La geometría tarda algunos cuadros en generarse (los sistemas trabajan
+    // sobre el conjunto de nodos sucios).
+    const marco = pagina.frameLocator('iframe[title="Pascal Editor"]')
+    await marco.locator('canvas').first().waitFor({ timeout: 120_000 })
+
+    const cuadro = pagina.frames().find((f) => f.url().endsWith('/'))
+    await cuadro.waitForFunction(
+      () => {
+        const sonda = window.__holtmontProbe?.()
+        return sonda && (sonda.porTipo.wall?.conGeometria ?? 0) > 0
+      },
+      null,
+      { timeout: 120_000 },
+    )
+    const sonda = await cuadro.evaluate(() => window.__holtmontProbe())
+
+    const esperado = ESPERADO[escena] ?? {}
+    const problemas = []
+    for (const [tipo, minimo] of Object.entries(esperado)) {
+      const dibujados = sonda.porTipo[tipo]?.conGeometria ?? 0
+      if (dibujados < minimo) {
+        problemas.push(`${tipo}: ${dibujados} con geometría, se esperaban ${minimo}`)
+      }
+    }
+    if (sonda.mayorLado < 1) {
+      problemas.push(`la escena mide ${sonda.mayorLado.toFixed(3)} m: no hay nada dibujado`)
+    }
+    // Un error de render mata el bucle de react-three-fiber sin decir nada:
+    // esto es lo que dejaba el plano en negro.
+    if (erroresDeConsola.length > 0) {
+      problemas.push(`errores en consola: ${erroresDeConsola.slice(0, 3).join(' | ')}`)
+    }
+
+    if (CAPTURAS) {
+      await pagina.screenshot({ path: join(CAPTURAS, `${escena}.png`) })
+    }
+
+    if (problemas.length > 0) throw new Error(problemas.join('; '))
+
+    const resumen = Object.entries(sonda.porTipo)
+      .map(([tipo, v]) => `${tipo} ${v.conGeometria}/${v.total}`)
+      .join(', ')
+    console.log(`OK   ${escena} — ${resumen}`)
+  } catch (err) {
+    fallos += 1
+    console.error(`FALLA ${escena} — ${err.message}`)
+    if (CAPTURAS) {
+      await pagina.screenshot({ path: join(CAPTURAS, `${escena}-FALLA.png`) }).catch(() => {})
+    }
+  } finally {
+    await contexto.close()
+  }
+}
+
+await navegador.close()
+
+if (fallos > 0) {
+  console.error(`\n${fallos} escena(s) no se dibujan.`)
+  process.exit(1)
+}
+console.log(`\n${escenas.length} escena(s) se dibujan correctamente.`)
diff --git a/bun.lock b/bun.lock
index faa9b5693e..98cb5150f6 100644
--- a/bun.lock
+++ b/bun.lock
@@ -40,6 +40,7 @@
         "@types/react": "19.2.2",
         "@types/react-dom": "19.2.2",
         "agentation": "^2.3.2",
+        "playwright": "^1.63.0",
         "react-grab": "^0.1.25",
         "react-scan": "^0.5.3",
         "tw-animate-css": "^1.4.0",
@@ -1169,6 +1170,10 @@
 
     "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
 
+    "playwright": ["playwright@1.63.0", "", { "dependencies": { "playwright-core": "1.63.0" }, "bin": { "playwright": "cli.js" } }, "sha512-+7ziBLidS4NaNCdt57SUDT+wYmmd5fmiQejUic/kb+YsYSCPyOOE9sebzMjNmQrsnNpDJqd4WHvV/8lfKfUDUg=="],
+
+    "playwright-core": ["playwright-core@1.63.0", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-rYCsBF/M5HjUch52bbtVONEFjv6Xu8sm8h72dNlR5bzIE1fvC/bxgspzkjSfU+MweEMmPM8KJebG6nnyxo5mCg=="],
+
     "polygon-clipping": ["polygon-clipping@0.15.7", "", { "dependencies": { "robust-predicates": "^3.0.2", "splaytree": "^3.1.0" } }, "sha512-nhfdr83ECBg6xtqOAJab1tbksbBAOMUltN60bU+llHVOL0e5Onm1WpAXXWXVB39L8AJFssoIhEVuy/S90MmotA=="],
 
     "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="],
diff --git a/package.json b/package.json
index 10b3d7f584..31db3d300d 100644
--- a/package.json
+++ b/package.json
@@ -3,6 +3,7 @@
   "private": true,
   "scripts": {
     "build": "turbo run build",
+    "test": "bun test",
     "dev": "set -a && . ./.env 2>/dev/null; set +a; turbo run dev --env-mode=loose",
     "lint": "biome lint",
     "lint:fix": "biome lint --write",
diff --git a/packages/core/package.json b/packages/core/package.json
index 05551fe476..b5f5ebfab7 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -11,6 +11,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./schema": {
+      "types": "./dist/schema/index.d.ts",
+      "import": "./dist/schema/index.js",
+      "default": "./dist/schema/index.js"
+    },
     "./clone-scene-graph": {
       "types": "./dist/utils/clone-scene-graph.d.ts",
       "import": "./dist/utils/clone-scene-graph.js",
diff --git a/packages/core/src/schema/nodes/level.ts b/packages/core/src/schema/nodes/level.ts
index 4761161c00..9ef5cd0659 100644
--- a/packages/core/src/schema/nodes/level.ts
+++ b/packages/core/src/schema/nodes/level.ts
@@ -4,6 +4,7 @@ import { BaseNode, nodeType, objectId } from '../base'
 import { CeilingNode } from './ceiling'
 import { FenceNode } from './fence'
 import { GuideNode } from './guide'
+import { ItemNode } from './item'
 import { RoofNode } from './roof'
 import { ScanNode } from './scan'
 import { SlabNode } from './slab'
@@ -18,6 +19,11 @@ export const LevelNode = BaseNode.extend({
     .array(
       z.union([
         WallNode.shape.id,
+        // Los muebles se crean con el nivel como padre (`use-draft-node.ts`
+        // usa `selection.levelId`), y la descripción de abajo ya los nombraba;
+        // faltaban en la unión, así que un nivel con muebles no pasaba
+        // `LevelNode.parse()`.
+        ItemNode.shape.id,
         FenceNode.shape.id,
         ZoneNode.shape.id,
         SlabNode.shape.id,
diff --git a/packages/viewer/src/components/viewer/post-processing.tsx b/packages/viewer/src/components/viewer/post-processing.tsx
index 96c8c6904f..53a23efc63 100644
--- a/packages/viewer/src/components/viewer/post-processing.tsx
+++ b/packages/viewer/src/components/viewer/post-processing.tsx
@@ -180,15 +180,24 @@ const PostProcessingPasses = ({
     hasPipelineErrorRef.current = false
 
     // WebGPU availability check: SSGI, denoise, and RenderPipeline are all
-    // WebGPU-only APIs. When the browser falls back to WebGL2 (no
-    // `navigator.gpu`, or the device couldn't be created), building the
-    // pipeline either throws silently or produces a broken output where
-    // the scene renders for a few frames and then goes black as the retry
-    // loop fights the direct-render fallback path. Short-circuit here so
-    // `useFrame` uses the direct `renderer.render(scene, camera)` path
-    // exclusively and never attempts the TSL pipeline.
-    const hasWebGPU = typeof navigator !== 'undefined' && 'gpu' in navigator
-    if (!hasWebGPU) {
+    // WebGPU-only APIs. When the browser falls back to WebGL2, building the
+    // pipeline produces un output roto: la escena se queda en negro y la
+    // consola se llena de
+    // «GL_INVALID_OPERATION: glDrawArrays: Feedback loop formed between
+    // Framebuffer and active Texture». Short-circuit here so `useFrame` uses
+    // the direct `renderer.render(scene, camera)` path exclusively and never
+    // attempts the TSL pipeline.
+    //
+    // La comprobación es sobre el backend que quedó, no sobre `navigator.gpu`:
+    // Chromium expone `navigator.gpu` en máquinas donde el dispositivo WebGPU
+    // no se puede crear (sin GPU, con drivers viejos, o bajo swiftshader), y
+    // ahí three cae a WebGL2 por su cuenta —«WebGPURenderer: WebGPU is not
+    // available, running under WebGL2 backend»— mientras esta comprobación
+    // seguía dando por buena la ruta WebGPU. Ese desacuerdo era el lienzo
+    // negro: `renderer.init()` ya terminó cuando corre este efecto, así que
+    // `backend` es el definitivo.
+    const backend = (renderer as unknown as { backend?: { isWebGPUBackend?: boolean } }).backend
+    if (backend?.isWebGPUBackend !== true) {
       console.warn(
         '[viewer] WebGPU unavailable — rendering without post-processing (SSGI, outlines, denoise).',
       )