@pascal-app/editor 1.0.0 → 1.0.1

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

@@ -1,25 +1,30 @@
-import { describe, expect, test } from 'bun:test'
+import { afterEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeDefinition,
+  BuildingNode,
   type FloorplanGeometry,
   type GeometryContext,
+  LevelNode,
   loadPlugin,
   type NodeCategory,
   nodeRegistry,
   registerNode,
 } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
 import PDFDocument from 'pdfkit'
 import { z } from 'zod'
 import { splitFloorplanOverlay } from '../../components/editor-2d/renderers/floorplan-registry-layer'
 import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
 import {
   collectFloorplanGeometry,
+  collectFloorplanSchedules,
   filterFloorplanExportOverlay,
   fitPlanToBox,
   isFloorplanExportAnnotationGeometry,
   isFloorplanNodeInExportScope,
   partitionFloorplanExportOverlay,
+  resolveExportLevels,
   resolveFloorplanExportAnnotationVisibility,
   resolveFloorplanExportNodeGeometry,
   resolveFloorplanExportPlacement,
@@ -424,6 +429,81 @@ describe('isFloorplanNodeInExportScope', () => {
   })
 })
 
+describe('collectFloorplanSchedules', () => {
+  test('omits non-structure schedule contributors under structure scope', () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    const structureKind = 'test:structure-schedule'
+    const siteKind = 'test:site-schedule'
+    const levelId = 'level_schedules' as AnyNode['id']
+    const structureNodeId = 'structure_scheduled' as AnyNode['id']
+    const siteNodeId = 'site_scheduled' as AnyNode['id']
+
+    const scheduleFor = (title: string) => ({
+      id: title.toLowerCase(),
+      title,
+      columns: [{ key: 'id', label: 'ID' }],
+      rows: [{ id: 'row', cells: { id: '1' } }],
+    })
+
+    try {
+      nodeRegistry._reset()
+      registerNode({
+        kind: structureKind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(structureKind) }) as never,
+        category: 'structure',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        extensions: {
+          'pascal:editor/floorplan': {
+            schedule: () => scheduleFor('Doors'),
+          },
+        },
+      } as AnyNodeDefinition)
+      registerNode({
+        kind: siteKind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(siteKind) }) as never,
+        category: 'site',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        extensions: {
+          'pascal:editor/floorplan': {
+            schedule: () => scheduleFor('Rooms'),
+          },
+        },
+      } as AnyNodeDefinition)
+
+      const nodes = {
+        [levelId]: {
+          id: levelId,
+          type: 'level',
+          visible: true,
+          children: [structureNodeId, siteNodeId],
+        },
+        [structureNodeId]: {
+          id: structureNodeId,
+          type: structureKind,
+          visible: true,
+        },
+        [siteNodeId]: {
+          id: siteNodeId,
+          type: siteKind,
+          visible: true,
+        },
+      } as unknown as Record<string, AnyNode>
+
+      const full = collectFloorplanSchedules(nodes, levelId, 'metric', 'full')
+      expect(full.map((schedule) => schedule.title).sort()).toEqual(['Doors', 'Rooms'])
+
+      const structure = collectFloorplanSchedules(nodes, levelId, 'metric', 'structure')
+      expect(structure.map((schedule) => schedule.title)).toEqual(['Doors'])
+    } finally {
+      restoreRegistry()
+    }
+  })
+})
+
 describe('collectFloorplanGeometry', () => {
   test('collects the active Site once below architecture with semantic context and projection', async () => {
     const restoreRegistry = nodeRegistry._snapshot()
@@ -713,3 +793,61 @@ describe('collectFloorplanGeometry', () => {
     }
   })
 })
+
+describe('resolveExportLevels', () => {
+  const ground = LevelNode.parse({ id: 'level_ground', parentId: 'building_a', level: 0 })
+  const upper = LevelNode.parse({ id: 'level_upper', parentId: 'building_a', level: 1 })
+  const roof = LevelNode.parse({
+    id: 'level_roof',
+    parentId: 'building_a',
+    level: 2,
+    metadata: { role: 'roof', referenceLevelId: upper.id },
+  })
+  const attic = LevelNode.parse({
+    id: 'level_attic',
+    parentId: 'building_a',
+    level: 3,
+    metadata: { role: 'attic' },
+  })
+  const building = BuildingNode.parse({
+    id: 'building_a',
+    children: [ground.id, upper.id, roof.id, attic.id],
+  })
+  const nodes: Record<string, AnyNode> = Object.fromEntries(
+    [building, ground, upper, roof, attic].map((node) => [node.id, node]),
+  )
+
+  // The viewer store is a process-wide singleton, so an earlier test file can
+  // leak a selection into these tests; restore it instead of leaving ours.
+  const previousSelection = useViewer.getState().selection
+
+  const selectLevel = (levelId: string | null) => {
+    useViewer.setState({
+      selection: { ...previousSelection, buildingId: building.id, levelId },
+    } as never)
+  }
+
+  afterEach(() => {
+    useViewer.setState({ selection: previousSelection } as never)
+  })
+
+  test('skips a dedicated roof support level', () => {
+    selectLevel(ground.id)
+
+    expect(resolveExportLevels(nodes)).toEqual([
+      { id: ground.id, label: 'Level 0' },
+      { id: upper.id, label: 'Level 1' },
+      { id: attic.id, label: 'Level 3' },
+    ])
+  })
+
+  test('skips the roof level when it is the selected level', () => {
+    selectLevel(roof.id)
+
+    expect(resolveExportLevels(nodes)).toEqual([
+      { id: ground.id, label: 'Level 0' },
+      { id: upper.id, label: 'Level 1' },
+      { id: attic.id, label: 'Level 3' },
+    ])
+  })
+})

package/src/lib/floorplan/floorplan-export.tsx

@@ -219,7 +219,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
         wallDimensionReference,
         installedPlugins,
       )
-      const schedules = collectFloorplanSchedules(nodes, level.id, unit)
+      const schedules = collectFloorplanSchedules(nodes, level.id, unit, scope)
       if (geometries.length === 0 && schedules.length === 0) continue
       const layout = resolveFloorplanPageLayout(A4_LANDSCAPE_WIDTH_PT, A4_LANDSCAPE_HEIGHT_PT)
 
@@ -305,6 +305,7 @@ export function collectFloorplanSchedules(
   nodes: Record<string, AnyNode>,
   levelId: AnyNodeId,
   unit: 'metric' | 'imperial',
+  scope: FloorplanExportScope = 'full',
 ): FloorplanSchedule[] {
   const siblingsByType = new Map<string, AnyNode[]>()
   const visit = (id: AnyNodeId) => {
@@ -324,6 +325,9 @@ export function collectFloorplanSchedules(
   for (const [kind, definition] of nodeRegistry.entries()) {
     const scheduleContribution = getFloorplanNodeExtension(definition)?.schedule
     if (!scheduleContribution) continue
+    // Same scope gate as geometry: a structure-only PDF must not list rooms
+    // or other site-category contributors whose plan geometry was excluded.
+    if (!isFloorplanNodeInExportScope(definition, scope)) continue
     const siblings = siblingsByType.get(kind) ?? []
     const schedule = scheduleContribution({ siblings, nodes, levelId, unit })
     if (schedule && schedule.rows.length > 0) schedules.push(schedule)
@@ -1021,9 +1025,10 @@ function combineGeometryList(
  * Levels to export, ordered bottom-to-top. The active building (the building
  * owning the selected level, or the first one found) contributes all of its
  * level children; if there is no building wrapper we fall back to the single
- * resolved level.
+ * resolved level. Roof support levels are excluded: they are not occupied
+ * stories, so they do not get a floor-plan page.
  */
-function resolveExportLevels(nodes: Record<string, AnyNode>): ExportLevel[] {
+export function resolveExportLevels(nodes: Record<string, AnyNode>): ExportLevel[] {
   const selected = useViewer.getState().selection.levelId as AnyNodeId | null | undefined
   const activeLevelId = selected && nodes[selected] ? selected : firstLevelId(nodes)
   if (!activeLevelId) return []
@@ -1038,6 +1043,7 @@ function resolveExportLevels(nodes: Record<string, AnyNode>): ExportLevel[] {
     levelNodes = node ? [node] : []
   }
 
+  levelNodes = levelNodes.filter((n) => n.metadata.role !== 'roof')
   levelNodes.sort((a, b) => levelIndexOf(a) - levelIndexOf(b))
   return levelNodes.map((n) => ({ id: n.id as AnyNodeId, label: levelLabelOf(n) }))
 }

package/src/lib/floorplan/floorplan-readonly.ts

@@ -14,6 +14,8 @@ export type FloorplanViewState = {
   highlighted: boolean
   hovered: boolean
   moving: boolean
+  focusedUnitId?: string
+  focusedUnitMemberIds?: readonly string[]
   palette: FloorplanPalette | undefined
 }
 
@@ -66,6 +68,8 @@ export function buildFloorplanContext(
           highlighted: viewState.highlighted,
           hovered: viewState.hovered,
           moving: viewState.moving,
+          focusedUnitId: viewState.focusedUnitId,
+          focusedUnitMemberIds: viewState.focusedUnitMemberIds,
           palette: viewState.palette,
         }
       : undefined,

package/src/lib/fresh-planar-placement.ts

@@ -8,6 +8,11 @@ import {
   useScene,
 } from '@pascal-app/core'
 import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
+import {
+  surfaceAttachmentId,
+  surfaceAttachmentUpdates,
+  updateSurfaceNode,
+} from './surface-attachment'
 
 function cleanPlacementMetadata<N extends AnyNode>(node: N): N {
   return {
@@ -131,16 +136,19 @@ export function commitFreshPlacementSubtree(
     parentId,
   })
 
+  const surfaceId = surfaceAttachmentId(subtree.root)
   const temporal = useScene.temporal.getState()
   const wasTracking = (temporal as { isTracking?: boolean }).isTracking !== false
   if (wasTracking) temporal.pause()
+  updateSurfaceNode(rootId, {}, null)
   useScene.getState().deleteNode(rootId)
   temporal.resume()
-  useScene
-    .getState()
-    .createNodes(
-      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
-    )
+  useScene.getState().applyNodeChanges({
+    create: cloned.nodes.map((node, index) =>
+      index === 0 && parentId ? { node, parentId } : { node },
+    ),
+    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId),
+  })
   if (!wasTracking) temporal.pause()
 
   return cloned.rootId

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

@@ -0,0 +1,280 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  DoorNode,
+  nodeRegistry,
+  registerNode,
+  sceneRegistry,
+} from '@pascal-app/core'
+import * as THREE from 'three'
+import type { ExportTextureUtils } from './export-texture-utils'
+import {
+  exportSceneToGlb,
+  type GlbExport,
+  serializePreparedSceneToGlb,
+  withExportDeadline,
+} from './glb-export'
+
+// GLTFExporter's binary path runs through document.createElement('canvas'),
+// canvas.toBlob and three FileReader reads (image bufferView, merged buffer,
+// final GLB). Bun has none of those, so a minimal stand-in drives the exporter
+// the way a browser does — including the failure the browser reports only via
+// `result === null` inside `onloadend`.
+type Globals = Record<string, unknown>
+const globals = globalThis as unknown as Globals
+const DOM_KEYS = ['document', 'FileReader', 'ImageData', 'HTMLCanvasElement'] as const
+const previous = new Map<string, unknown>()
+
+class FakeImageData {
+  constructor(
+    public data: Uint8ClampedArray,
+    public width: number,
+    public height: number,
+  ) {}
+}
+
+class FakeCanvas {
+  width = 0
+  height = 0
+  private pixels: Uint8ClampedArray | null = null
+
+  getContext() {
+    return {
+      translate: () => {},
+      scale: () => {},
+      drawImage: () => {},
+      fillRect: () => {},
+      createImageData: (width: number, height: number) =>
+        new FakeImageData(new Uint8ClampedArray(width * height * 4), width, height),
+      putImageData: (image: FakeImageData) => {
+        this.pixels = new Uint8ClampedArray(image.data)
+      },
+      getImageData: (_x: number, _y: number, width: number, height: number) =>
+        new FakeImageData(this.pixels ?? new Uint8ClampedArray(width * height * 4), width, height),
+    }
+  }
+
+  toBlob(callback: (blob: Blob) => void, mimeType: string) {
+    callback(new Blob([new Uint8Array([137, 80, 78, 71])], { type: mimeType }))
+  }
+}
+
+type FileReaderBehaviour = {
+  reads: number
+  /** 1-based index of the read whose result is `null`, as after a failed read. */
+  failAt: number
+}
+
+function installExporterDom(behaviour: FileReaderBehaviour) {
+  for (const key of DOM_KEYS) previous.set(key, globals[key])
+
+  class FakeFileReader {
+    result: ArrayBuffer | null = null
+    onloadend: (() => void) | null = null
+    readAsArrayBuffer(blob: Blob) {
+      behaviour.reads += 1
+      const read = behaviour.reads
+      void blob.arrayBuffer().then((buffer) => {
+        this.result = read === behaviour.failAt ? null : buffer
+        // Browsers report an exception thrown inside the event handler to
+        // window.onerror; it never reaches the exporter's promise chain.
+        try {
+          this.onloadend?.()
+        } catch {}
+      })
+    }
+  }
+
+  globals.ImageData = FakeImageData
+  globals.HTMLCanvasElement = FakeCanvas
+  globals.FileReader = FakeFileReader
+  globals.document = {
+    createElement: (tagName: string) => {
+      if (tagName !== 'canvas') throw new Error(`Unexpected element request: ${tagName}`)
+      return new FakeCanvas()
+    },
+  }
+}
+
+afterEach(() => {
+  for (const key of DOM_KEYS) globals[key] = previous.get(key)
+})
+
+function texturedRoot(texture: THREE.Texture): THREE.Group {
+  const root = new THREE.Group()
+  root.add(
+    new THREE.Mesh(
+      new THREE.BoxGeometry(1, 1, 1),
+      new THREE.MeshStandardMaterial({ map: texture }),
+    ),
+  )
+  return root
+}
+
+function texturedScene(texture: THREE.Texture): GlbExport {
+  return { scene: texturedRoot(texture), animations: [], warnings: [], dispose: () => {} }
+}
+
+function readableTexture(): THREE.DataTexture {
+  const texture = new THREE.DataTexture(new Uint8Array([255, 0, 0, 255]), 1, 1)
+  texture.needsUpdate = true
+  return texture
+}
+
+function passthroughUtils(): ExportTextureUtils & { calls: THREE.Texture[] } {
+  const calls: THREE.Texture[] = []
+  return {
+    calls,
+    decompress: async (texture) => {
+      calls.push(texture)
+      return readableTexture()
+    },
+    dispose: async () => {},
+  }
+}
+
+const GLB_MAGIC = 0x46546c67
+
+describe('serializePreparedSceneToGlb', () => {
+  test('resolves a binary glTF and routes compressed textures through the shared decompressor', async () => {
+    installExporterDom({ reads: 0, failAt: Number.POSITIVE_INFINITY })
+    const compressed = new THREE.CompressedTexture([], 2, 2)
+    compressed.name = 'Color_ktx2'
+    const textureUtils = passthroughUtils()
+
+    const glb = await serializePreparedSceneToGlb(texturedScene(compressed), { textureUtils })
+
+    expect(glb).toBeInstanceOf(ArrayBuffer)
+    expect(new DataView(glb).getUint32(0, true)).toBe(GLB_MAGIC)
+    expect(new DataView(glb).getUint32(8, true)).toBe(glb.byteLength)
+    expect(textureUtils.calls.map((texture) => texture.name)).toEqual(['Color_ktx2'])
+  })
+
+  test('rejects instead of resolving null when the final GLB read fails', async () => {
+    installExporterDom({ reads: 0, failAt: 3 })
+
+    await expect(
+      serializePreparedSceneToGlb(texturedScene(readableTexture()), {
+        textureUtils: passthroughUtils(),
+      }),
+    ).rejects.toThrow('GLB export produced no data')
+  })
+})
+
+describe('withExportDeadline', () => {
+  test('passes a settled value through and clears its timer', async () => {
+    await expect(withExportDeadline(Promise.resolve(7), 1_000, 'GLB')).resolves.toBe(7)
+  })
+
+  test('names the format and the wait in the timeout error', async () => {
+    const pending = new Promise<never>(() => {})
+    await expect(withExportDeadline(pending, 10, 'USDZ')).rejects.toThrow(
+      /USDZ export timed out after \d+ s/,
+    )
+  })
+
+  test('an infinite deadline returns the original promise', () => {
+    const pending = new Promise<never>(() => {})
+    expect(withExportDeadline(pending, Number.POSITIVE_INFINITY, 'GLB')).toBe(pending)
+  })
+})
+
+describe('exportSceneToGlb', () => {
+  afterEach(() => {
+    sceneRegistry.clear()
+  })
+
+  test('rejects at the deadline when a FileReader inside GLTFExporter fails silently', async () => {
+    // The image bufferView read is the first one; a null result throws inside
+    // onloadend, so GLTFExporter's pending list never drains.
+    installExporterDom({ reads: 0, failAt: 1 })
+
+    await expect(
+      exportSceneToGlb(
+        texturedRoot(readableTexture()),
+        {},
+        {
+          textureUtils: passthroughUtils(),
+          timeoutMs: 50,
+        },
+      ),
+    ).rejects.toThrow('GLB export timed out')
+  })
+
+  test('exports a live scene through a caller-owned decompressor without disposing it', async () => {
+    installExporterDom({ reads: 0, failAt: Number.POSITIVE_INFINITY })
+    const root = new THREE.Group()
+    root.add(
+      new THREE.Mesh(
+        new THREE.BoxGeometry(1, 1, 1),
+        new THREE.MeshStandardMaterial({ map: readableTexture() }),
+      ),
+    )
+    const textureUtils = passthroughUtils()
+    let disposals = 0
+    textureUtils.dispose = async () => {
+      disposals += 1
+    }
+
+    const glb = await exportSceneToGlb(root, {}, { textureUtils, timeoutMs: 5_000 })
+
+    expect(new DataView(glb).getUint32(0, true)).toBe(GLB_MAGIC)
+    expect(disposals).toBe(0)
+  })
+
+  test('rejects at the deadline when a plugin bake hook never settles', async () => {
+    installExporterDom({ reads: 0, failAt: Number.POSITIVE_INFINITY })
+    const restoreRegistry = nodeRegistry._snapshot()
+    try {
+      const kind = 'test:bake-never-settles'
+      registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: DoorNode,
+        category: 'furnish',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        bake: 'replace',
+        bakeGeometryAsync: () => new Promise<THREE.Object3D>(() => {}),
+      } as AnyNodeDefinition)
+      const source = new THREE.Group()
+      source.add(new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshStandardMaterial()))
+      const root = new THREE.Group()
+      root.add(source)
+      sceneRegistry.nodes.set('stuck_1', source)
+      const nodes = {
+        stuck_1: { id: 'stuck_1', type: kind, visible: true },
+      } as unknown as Record<string, AnyNode>
+
+      await expect(
+        exportSceneToGlb(root, nodes, { textureUtils: passthroughUtils(), timeoutMs: 50 }),
+      ).rejects.toThrow('GLB export timed out')
+    } finally {
+      restoreRegistry()
+    }
+  })
+
+  test('preparation and serialisation share one decompressor', async () => {
+    installExporterDom({ reads: 0, failAt: Number.POSITIVE_INFINITY })
+    const map = new THREE.CompressedTexture([], 2, 2)
+    map.name = 'Color_ktx2'
+    const normalMap = new THREE.CompressedTexture([], 2, 2)
+    normalMap.name = 'NormalGL_ktx2'
+    const material = new THREE.MeshStandardMaterial({ map, normalMap })
+    // A non-unit normalScale forces the preparation pass to bake (and so
+    // decompress) the normal map before the exporter ever sees it.
+    material.normalScale.set(0.5, 0.5)
+    const root = new THREE.Group()
+    root.add(new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), material))
+    const textureUtils = passthroughUtils()
+
+    const glb = await exportSceneToGlb(root, {}, { textureUtils, timeoutMs: 5_000 })
+
+    expect(new DataView(glb).getUint32(0, true)).toBe(GLB_MAGIC)
+    expect(textureUtils.calls.map((texture) => texture.name).sort()).toEqual([
+      'Color_ktx2',
+      'NormalGL_ktx2',
+    ])
+  })
+})