@pascal-app/editor 1.0.0 → 1.0.3

package/src/lib/export-texture-utils.ts

@@ -0,0 +1,121 @@
+import { initializeGpuRenderer } from '@pascal-app/viewer'
+import type * as THREE from 'three'
+import { texture as textureNode, uv } from 'three/tsl'
+import { CanvasTexture, NodeMaterial, QuadMesh, WebGPURenderer } from 'three/webgpu'
+
+/**
+ * GPU decompressor handed to three's GLTF/USDZ exporters for compressed (KTX2)
+ * textures. One instance lives for the duration of an export and is disposed
+ * with it.
+ */
+export type ExportTextureUtils = {
+  decompress(texture: THREE.Texture, maxTextureSize?: number): Promise<THREE.Texture>
+  dispose(): Promise<void>
+}
+
+// The WebGL probe context initializeGpuRenderer opens on this canvas is never
+// released, so one canvas serves every export instead of one per export.
+let probeCanvas: HTMLCanvasElement | null | undefined
+
+async function initializeDecompressRenderer(): Promise<WebGPURenderer> {
+  probeCanvas ??= typeof document === 'undefined' ? null : document.createElement('canvas')
+  const result = await initializeGpuRenderer({
+    probeCanvas,
+    createRenderer: (parameters) =>
+      new WebGPURenderer(parameters as ConstructorParameters<typeof WebGPURenderer>[0]),
+  })
+  if (result.status !== 'ready') {
+    throw new Error('Could not start a GPU renderer to decompress textures for export.', {
+      cause: result.error,
+    })
+  }
+  return result.renderer
+}
+
+function releaseDevice(renderer: WebGPURenderer) {
+  // initializeGpuRenderer hands three a caller-owned device, which
+  // WebGPUBackend.dispose() deliberately leaves alive.
+  const backend = renderer.backend as { device?: { destroy?: () => void } | null }
+  try {
+    backend.device?.destroy?.()
+  } catch {}
+}
+
+/**
+ * Mirrors three's `WebGPUTextureUtils.decompress` but keeps a single renderer
+ * for the whole export. The stock helper creates, initialises and disposes a
+ * WebGPURenderer — adapter and device request included, with no timeout — for
+ * every compressed texture it is handed, so a furnished scene paid that cost
+ * dozens of times and hung outright when one device request stalled. Handing
+ * it a renderer is not an option: it resizes whatever renderer it receives
+ * (the live viewer's canvas) and, in r186, throws on the first call that
+ * supplies one.
+ */
+export function createExportTextureUtils(
+  initialize: () => Promise<WebGPURenderer> = initializeDecompressRenderer,
+): ExportTextureUtils {
+  let pending: Promise<WebGPURenderer> | null = null
+  let disposed = false
+  const quad = new QuadMesh()
+
+  return {
+    async decompress(texture, maxTextureSize = Number.POSITIVE_INFINITY) {
+      if (disposed) {
+        throw new Error('The export was abandoned before this texture was decompressed.')
+      }
+      pending ??= initialize()
+      const renderer = await pending
+
+      // Everything below the await is synchronous, which is what lets
+      // overlapping calls share `quad` and the renderer's colour space.
+      const image = texture.image as { width: number; height: number }
+      const width = Math.min(image.width, maxTextureSize)
+      const height = Math.min(image.height, maxTextureSize)
+
+      const material = new NodeMaterial()
+      material.fragmentNode = textureNode(texture, uv().flipY())
+      const previousColorSpace = renderer.outputColorSpace
+      renderer.setSize(width, height)
+      renderer.outputColorSpace = texture.colorSpace
+      quad.material = material
+      try {
+        quad.render(renderer)
+      } finally {
+        renderer.outputColorSpace = previousColorSpace
+        material.dispose()
+      }
+
+      const canvas = document.createElement('canvas')
+      canvas.width = width
+      canvas.height = height
+      const context = canvas.getContext('2d')
+      if (!context) {
+        throw new Error('Could not create a 2D canvas to read back a decompressed texture.')
+      }
+      context.drawImage(renderer.domElement, 0, 0, width, height)
+
+      const readable = new CanvasTexture(canvas)
+      readable.minFilter = texture.minFilter
+      readable.magFilter = texture.magFilter
+      readable.wrapS = texture.wrapS
+      readable.wrapT = texture.wrapT
+      readable.colorSpace = texture.colorSpace
+      readable.name = texture.name
+      return readable
+    },
+
+    async dispose() {
+      disposed = true
+      const started = pending
+      pending = null
+      if (!started) return
+      const renderer = await started.catch(() => null)
+      if (!renderer) return
+      try {
+        await renderer.dispose()
+      } finally {
+        releaseDevice(renderer)
+      }
+    },
+  }
+}

package/src/lib/export-user-data.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test'
+import * as THREE from 'three'
+import { uniform } from 'three/tsl'
+import { cloneExportUserData } from './export-user-data'
+
+describe('cloneExportUserData', () => {
+  test('keeps plain data and deep-copies it', () => {
+    const source = {
+      pascalId: 'wall-1',
+      pascalSwingLeaf: { axis: 'y', openRotationY: 1.2 },
+      tags: ['a', 'b'],
+      offsets: new Float32Array([1, 2, 3]),
+    }
+    const copy = cloneExportUserData(source)
+    expect(copy).toEqual(source)
+    expect(copy.pascalSwingLeaf).not.toBe(source.pascalSwingLeaf)
+    expect(copy.tags).not.toBe(source.tags)
+    expect(copy.offsets).not.toBe(source.offsets)
+  })
+
+  test('drops functions and live three resources instead of throwing', () => {
+    const material = new THREE.MeshStandardMaterial()
+    material.addEventListener('dispose', () => {})
+    const source = {
+      pascalId: 'pool-1',
+      waterEffect: { material, uniforms: { time: uniform(0) }, strength: 0.5 },
+      mesh: new THREE.Mesh(new THREE.BoxGeometry(), material),
+      geometry: new THREE.BufferGeometry(),
+      texture: new THREE.Texture(),
+      onDispose: () => {},
+      list: [material, 'kept'],
+    }
+    expect(() => structuredClone(source)).toThrow()
+    expect(cloneExportUserData(source)).toEqual({
+      pascalId: 'pool-1',
+      waterEffect: { uniforms: {}, strength: 0.5 },
+      list: [undefined, 'kept'],
+    })
+  })
+
+  test('tolerates cycles', () => {
+    const source: Record<string, unknown> = { pascalId: 'x' }
+    source.self = source
+    const copy = cloneExportUserData(source)
+    expect(copy.pascalId).toBe('x')
+    expect(copy.self).toBe(copy)
+  })
+})

package/src/lib/export-user-data.ts

@@ -0,0 +1,69 @@
+/**
+ * Copy `userData` for an export clone. `structuredClone` throws the moment it
+ * meets a function, and live scenes keep runtime resources in userData (a
+ * plugin's effect material, TSL uniforms, a mesh reference) whose dispose
+ * listeners are functions — so a plain `structuredClone(userData)` aborts the
+ * whole export. Exports only ever read plain data back out of userData, so
+ * runtime resources and functions are dropped instead of cloned.
+ */
+
+type RuntimeResource = {
+  isObject3D?: boolean
+  isMaterial?: boolean
+  isTexture?: boolean
+  isBufferGeometry?: boolean
+  isNode?: boolean
+}
+
+function isRuntimeResource(value: object): boolean {
+  const flags = value as RuntimeResource
+  return Boolean(
+    flags.isObject3D ||
+      flags.isMaterial ||
+      flags.isTexture ||
+      flags.isBufferGeometry ||
+      flags.isNode,
+  )
+}
+
+function cloneValue(value: unknown, seen: Map<object, unknown>): unknown {
+  if (typeof value === 'function') return undefined
+  if (value === null || typeof value !== 'object') return value
+  if (seen.has(value)) return seen.get(value)
+  if (isRuntimeResource(value)) return undefined
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const copy = structuredClone(value)
+    seen.set(value, copy)
+    return copy
+  }
+  if (value instanceof Date || value instanceof RegExp) return structuredClone(value)
+  if (Array.isArray(value)) {
+    const copy: unknown[] = []
+    seen.set(value, copy)
+    for (const entry of value) copy.push(cloneValue(entry, seen))
+    return copy
+  }
+  if (value instanceof Map) {
+    const copy = new Map<unknown, unknown>()
+    seen.set(value, copy)
+    for (const [key, entry] of value) copy.set(cloneValue(key, seen), cloneValue(entry, seen))
+    return copy
+  }
+  if (value instanceof Set) {
+    const copy = new Set<unknown>()
+    seen.set(value, copy)
+    for (const entry of value) copy.add(cloneValue(entry, seen))
+    return copy
+  }
+  const copy: Record<string, unknown> = {}
+  seen.set(value, copy)
+  for (const [key, entry] of Object.entries(value)) {
+    const cloned = cloneValue(entry, seen)
+    if (cloned !== undefined) copy[key] = cloned
+  }
+  return copy
+}
+
+export function cloneExportUserData(userData: Record<string, unknown>): Record<string, unknown> {
+  return cloneValue(userData, new Map()) as Record<string, unknown>
+}

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()
@@ -694,7 +774,9 @@ describe('collectFloorplanGeometry', () => {
         'finished-faces',
         [enabledPluginId],
       )
-      expect(hiddenSite.map(({ id }) => id)).toEqual(['level_architecture'])
+      // A hidden Site hides only its own ground and boundary; the site-scoped
+      // nodes on it keep their own flag (see `hidesDescendants`).
+      expect(hiddenSite.map(({ id }) => id)).toEqual(['site_overlay', 'level_architecture'])
 
       const structure = collectFloorplanGeometry(
         nodes,
@@ -713,3 +795,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-extension.ts

@@ -57,13 +57,29 @@ export type FloorplanToolContext = {
 
 export type FloorplanNodeExtension<N extends AnyNode = AnyNode> = {
   tool?: () => Promise<{ default: ComponentType<FloorplanToolContext> }>
+  directDrag?: boolean
   availableModes?: readonly FloorplanToolMode[]
   preferredView?: '2d' | '3d'
   referencedSelectionAnnotationRole?: FloorplanAnnotationRole
   contextualDimensions?: (node: N, ctx: GeometryContext) => FloorplanGeometry | null
   actionMenu?: {
     canCurve?: (args: { node: N; nodes: Readonly<Record<AnyNodeId, AnyNode>> }) => boolean
+    /** Buttons the kind adds to the selection's action menu (2D and 3D); each decides its own visibility. */
+    actions?: () => Promise<{ default: ComponentType }>
   }
+  /**
+   * Plan layers mounted while a node of this kind is in a `reshaping` scope of
+   * that name (the 2D sibling of `def.affordanceTools[reshape]`).
+   */
+  reshapeLayers?: Record<string, () => Promise<{ default: ComponentType<FloorplanToolContext> }>>
+  /**
+   * Nodes the plan treats as one with this node when toggling it out of a
+   * selection (a slab and its ceiling share an outline and a click).
+   */
+  selectionCounterparts?: (args: {
+    node: N
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>
+  }) => AnyNodeId[]
   schedule?: (args: {
     siblings: ReadonlyArray<N>
     nodes: Readonly<Record<string, AnyNode>>

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,