@pascal-app/editor 1.0.4 → 1.0.5

package/src/lib/geometry-script/finish-scripts.ts

@@ -0,0 +1,127 @@
+import {
+  type AnyNodeId,
+  type CompiledGeometryScript,
+  type FinishScriptHost,
+  type FinishScriptInputs,
+  type FinishScriptTarget,
+  finishScriptWrites,
+  GEOMETRY_SCRIPT_MIME_TYPES,
+  type GeometryScriptParamValue,
+  getArtifactStore,
+  pauseSceneHistory,
+  refreshFinishScripts,
+  resumeSceneHistory,
+  staleFinishScripts,
+  useScene,
+} from '@pascal-app/core'
+import { compileGeometryScriptInWorker } from './client'
+
+/**
+ * Runs a finish script (a room's floor, a wall's face) in the sandbox for what it finishes and
+ * stores the GLB and the module text, answering the compile with the stored hashes
+ * (`setRoomFloorScript` and `setWallFaceScript` take it with its `inputs`).
+ */
+export async function compileAndStoreFinishScript(
+  input: FinishScriptTarget & {
+    code: string
+    params?: Record<string, GeometryScriptParamValue>
+    inputs: FinishScriptInputs
+  },
+): Promise<CompiledGeometryScript> {
+  const { glb, ...compiled } = await compileGeometryScriptInWorker({
+    code: input.code,
+    params: input.params,
+    inputs: input.inputs,
+  })
+  const context = {
+    nodeId: input.nodeId,
+    metadata: { name: input.face ? 'Wall finish' : 'Floor finish', mount: compiled.mount },
+  }
+  const store = getArtifactStore()
+  const [sha256] = await Promise.all([
+    store.put(compiled.sha256, glb, 'model/gltf-binary', context),
+    store.put(
+      compiled.script,
+      new TextEncoder().encode(input.code),
+      GEOMETRY_SCRIPT_MIME_TYPES.three,
+      context,
+    ),
+  ])
+  return { ...compiled, sha256 }
+}
+
+/** The editor tab's host for finish scripts: the sandbox compile and the scene's artifact store. */
+export const editorFinishScriptHost: FinishScriptHost = {
+  readScript: (sha256) => getArtifactStore().text(sha256),
+  build: compileAndStoreFinishScript,
+}
+
+/** The module text of a finish script, read back from the artifact store. */
+export function finishScriptCode(sha256: string): Promise<string | null> {
+  return getArtifactStore().text(sha256)
+}
+
+const SETTLE_MS = 150
+
+/**
+ * Keeps every finish script built for what it finishes: after a scene change settles, each script
+ * whose room's floor the structure re-derived, or whose wall face changed, runs again in the
+ * sandbox. The new build is written outside history, as the reconcile's derived writes are, and
+ * only while its floor or face is still the one it was built for; undo brings back the room or
+ * wall and the script built for it together.
+ */
+export function initFinishScriptRefresh(): () => void {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let running = false
+  let again = false
+
+  const run = async () => {
+    if (running) {
+      again = true
+      return
+    }
+    running = true
+    try {
+      const nodes = useScene.getState().nodes
+      if (useScene.getState().readOnly || staleFinishScripts(nodes).length === 0) return
+      const refresh = await refreshFinishScripts(nodes, editorFinishScriptHost)
+      for (const { nodeId, face, error } of refresh.failed)
+        console.error(
+          `[finish script] ${nodeId}${face ? ` face ${face}` : ''} could not be rebuilt: ${error}`,
+        )
+      const writes = finishScriptWrites(useScene.getState().nodes, refresh.rebuilt)
+      if (writes.length === 0) return
+      pauseSceneHistory(useScene)
+      try {
+        useScene
+          .getState()
+          .updateNodes(writes.map(({ id, data }) => ({ id: id as AnyNodeId, data })))
+      } finally {
+        resumeSceneHistory(useScene)
+      }
+    } finally {
+      running = false
+      if (again) {
+        again = false
+        schedule()
+      }
+    }
+  }
+
+  const schedule = () => {
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = null
+      void run()
+    }, SETTLE_MS)
+  }
+
+  const unsubscribe = useScene.subscribe((state, previous) => {
+    if (state.nodes !== previous.nodes) schedule()
+  })
+  schedule()
+  return () => {
+    unsubscribe()
+    if (timer) clearTimeout(timer)
+  }
+}

package/src/lib/geometry-script/protocol.ts

@@ -5,6 +5,7 @@ export type GeometryScriptWorkerRequest = {
   id: number
   code: string
   params?: Record<string, GeometryScriptParamValue>
+  inputs?: Record<string, unknown>
 }
 
 export type GeometryScriptWorkerResponse =

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

@@ -95,21 +95,21 @@ function sceneWithVisibleAndHiddenBoxes(): {
 }
 
 describe('prepareSceneForExport', () => {
-  test.each([
-    true,
-    false,
-  ])('omits registered draft geometry absent from the saved document (onlyVisible=%s)', (onlyVisible) => {
-    const { root, nodes } = sceneWithVisibleAndHiddenBoxes()
-    const draft = sceneRegistry.nodes.get('item_hidden')!
-    draft.name = 'Unplaced preview'
-    nodes.item_hidden!.visible = true
-    delete nodes.item_hidden
-
-    const result = prepareSceneForExport(root, nodes, { onlyVisible })
-    expect(result.scene.getObjectByName('Unplaced preview')).toBeUndefined()
-    expect(result.scene.children).toHaveLength(1)
-    expect(root.getObjectByName('Unplaced preview')).toBe(draft)
-  })
+  test.each([true, false])(
+    'omits registered draft geometry absent from the saved document (onlyVisible=%s)',
+    (onlyVisible) => {
+      const { root, nodes } = sceneWithVisibleAndHiddenBoxes()
+      const draft = sceneRegistry.nodes.get('item_hidden')!
+      draft.name = 'Unplaced preview'
+      nodes.item_hidden!.visible = true
+      delete nodes.item_hidden
+
+      const result = prepareSceneForExport(root, nodes, { onlyVisible })
+      expect(result.scene.getObjectByName('Unplaced preview')).toBeUndefined()
+      expect(result.scene.children).toHaveLength(1)
+      expect(root.getObjectByName('Unplaced preview')).toBe(draft)
+    },
+  )
 
   test('skips a refused subtree and reports its warning while exporting other objects', () => {
     const root = new THREE.Group()
@@ -457,134 +457,133 @@ describe('prepareSceneForExport', () => {
     }
   })
 
-  test.each([
-    'sync',
-    'portable-sync',
-    'portable-async',
-  ] as const)('bakes Site bounds and same-kind sibling reservations through %s hooks', async (mode) => {
-    const restoreRegistry = nodeRegistry._snapshot()
-    try {
-      const kind = 'test:site-context-bake'
-      const nodeId = 'site_context_bake'
-      const site = SiteNode.parse({
-        polygon: {
-          type: 'polygon',
-          points: [
-            [0, 0],
-            [12, 0],
-            [12, 8],
-            [0, 8],
-          ],
-        },
-        children: [nodeId, 'declared_sibling', 'linked_sibling', 'other_kind'],
-      })
-      const otherSite = SiteNode.parse({
-        polygon: {
-          type: 'polygon',
-          points: [
-            [0, 0],
-            [30, 0],
-            [30, 4],
-            [0, 4],
-          ],
-        },
-        children: ['other_site_sibling'],
-      })
-      const buildGeometry = (context: GeometryContext) => {
-        const points = (context.parent as SiteNode | null)?.polygon?.points ?? [[0, 0]]
-        const xs = points.map(([x]) => x)
-        const zs = points.map(([, z]) => z)
-        const reservedWidth = context.siblings.reduce(
-          (width, sibling) => width + Number(sibling.metadata?.reservedWidth ?? 0),
-          0,
-        )
-        return new THREE.Mesh(
-          new THREE.BoxGeometry(
-            Math.max(...xs) - Math.min(...xs) - reservedWidth,
-            1,
-            Math.max(...zs) - Math.min(...zs),
-          ),
-          new THREE.MeshStandardMaterial(),
-        )
-      }
-      registerNode({
-        kind,
-        schemaVersion: 1,
-        schema: DoorNode,
-        category: 'furnish',
-        defaults: () => ({}) as never,
-        capabilities: {},
-        bake: 'replace',
-        ...(mode === 'portable-async'
-          ? { bakeGeometryAsync: async (_node, context) => buildGeometry(context) }
-          : { bakeGeometry: (_node, context) => buildGeometry(context) }),
-      } as AnyNodeDefinition)
-      const nodes = {
-        [site.id]: site,
-        [otherSite.id]: otherSite,
-        [nodeId]: {
-          id: nodeId,
-          type: kind,
-          parentId: null,
-          visible: true,
-          metadata: { reservedWidth: 100 },
-        },
-        declared_sibling: {
-          id: 'declared_sibling',
-          type: kind,
-          parentId: null,
-          metadata: { reservedWidth: 2 },
-        },
-        pointer_sibling: {
-          id: 'pointer_sibling',
-          type: kind,
-          parentId: site.id,
-          metadata: { reservedWidth: 3 },
-        },
-        linked_sibling: {
-          id: 'linked_sibling',
-          type: kind,
-          parentId: site.id,
-          metadata: { reservedWidth: 1 },
-        },
-        other_kind: {
-          id: 'other_kind',
-          type: 'test:other-kind',
-          parentId: site.id,
-          metadata: { reservedWidth: 100 },
-        },
-        other_site_sibling: {
-          id: 'other_site_sibling',
-          type: kind,
-          parentId: otherSite.id,
-          metadata: { reservedWidth: 4 },
-        },
-      } as unknown as Record<string, AnyNode>
-      const root = new THREE.Group()
-      const source = new THREE.Group()
-      root.add(source)
-      sceneRegistry.nodes.set(nodeId, source)
-      const prepare = mode === 'sync' ? prepareSceneForExport : prepareSceneForExportAsync
-      const exportedSize = async () => {
-        const prepared = await prepare(root, nodes)
-        try {
-          const exported = prepared.scene.getObjectByName(nodeId)!
-          return new THREE.Box3().setFromObject(exported).getSize(new THREE.Vector3()).toArray()
-        } finally {
-          prepared.dispose()
+  test.each(['sync', 'portable-sync', 'portable-async'] as const)(
+    'bakes Site bounds and same-kind sibling reservations through %s hooks',
+    async (mode) => {
+      const restoreRegistry = nodeRegistry._snapshot()
+      try {
+        const kind = 'test:site-context-bake'
+        const nodeId = 'site_context_bake'
+        const site = SiteNode.parse({
+          polygon: {
+            type: 'polygon',
+            points: [
+              [0, 0],
+              [12, 0],
+              [12, 8],
+              [0, 8],
+            ],
+          },
+          children: [nodeId, 'declared_sibling', 'linked_sibling', 'other_kind'],
+        })
+        const otherSite = SiteNode.parse({
+          polygon: {
+            type: 'polygon',
+            points: [
+              [0, 0],
+              [30, 0],
+              [30, 4],
+              [0, 4],
+            ],
+          },
+          children: ['other_site_sibling'],
+        })
+        const buildGeometry = (context: GeometryContext) => {
+          const points = (context.parent as SiteNode | null)?.polygon?.points ?? [[0, 0]]
+          const xs = points.map(([x]) => x)
+          const zs = points.map(([, z]) => z)
+          const reservedWidth = context.siblings.reduce(
+            (width, sibling) => width + Number(sibling.metadata?.reservedWidth ?? 0),
+            0,
+          )
+          return new THREE.Mesh(
+            new THREE.BoxGeometry(
+              Math.max(...xs) - Math.min(...xs) - reservedWidth,
+              1,
+              Math.max(...zs) - Math.min(...zs),
+            ),
+            new THREE.MeshStandardMaterial(),
+          )
+        }
+        registerNode({
+          kind,
+          schemaVersion: 1,
+          schema: DoorNode,
+          category: 'furnish',
+          defaults: () => ({}) as never,
+          capabilities: {},
+          bake: 'replace',
+          ...(mode === 'portable-async'
+            ? { bakeGeometryAsync: async (_node, context) => buildGeometry(context) }
+            : { bakeGeometry: (_node, context) => buildGeometry(context) }),
+        } as AnyNodeDefinition)
+        const nodes = {
+          [site.id]: site,
+          [otherSite.id]: otherSite,
+          [nodeId]: {
+            id: nodeId,
+            type: kind,
+            parentId: null,
+            visible: true,
+            metadata: { reservedWidth: 100 },
+          },
+          declared_sibling: {
+            id: 'declared_sibling',
+            type: kind,
+            parentId: null,
+            metadata: { reservedWidth: 2 },
+          },
+          pointer_sibling: {
+            id: 'pointer_sibling',
+            type: kind,
+            parentId: site.id,
+            metadata: { reservedWidth: 3 },
+          },
+          linked_sibling: {
+            id: 'linked_sibling',
+            type: kind,
+            parentId: site.id,
+            metadata: { reservedWidth: 1 },
+          },
+          other_kind: {
+            id: 'other_kind',
+            type: 'test:other-kind',
+            parentId: site.id,
+            metadata: { reservedWidth: 100 },
+          },
+          other_site_sibling: {
+            id: 'other_site_sibling',
+            type: kind,
+            parentId: otherSite.id,
+            metadata: { reservedWidth: 4 },
+          },
+        } as unknown as Record<string, AnyNode>
+        const root = new THREE.Group()
+        const source = new THREE.Group()
+        root.add(source)
+        sceneRegistry.nodes.set(nodeId, source)
+        const prepare = mode === 'sync' ? prepareSceneForExport : prepareSceneForExportAsync
+        const exportedSize = async () => {
+          const prepared = await prepare(root, nodes)
+          try {
+            const exported = prepared.scene.getObjectByName(nodeId)!
+            return new THREE.Box3().setFromObject(exported).getSize(new THREE.Vector3()).toArray()
+          } finally {
+            prepared.dispose()
+          }
         }
-      }
 
-      expect(await exportedSize()).toEqual([6, 1, 8])
-      nodes[nodeId]!.parentId = otherSite.id
-      expect(await exportedSize()).toEqual([26, 1, 4])
-      nodes[nodeId]!.parentId = null
-      site.children = site.children.filter((id) => id !== nodeId)
-      expect(await exportedSize()).toEqual([0, 1, 0])
-    } finally {
-      restoreRegistry()
-    }
-  })
+        expect(await exportedSize()).toEqual([6, 1, 8])
+        nodes[nodeId]!.parentId = otherSite.id
+        expect(await exportedSize()).toEqual([26, 1, 4])
+        nodes[nodeId]!.parentId = null
+        site.children = site.children.filter((id) => id !== nodeId)
+        expect(await exportedSize()).toEqual([0, 1, 0])
+      } finally {
+        restoreRegistry()
+      }
+    },
+  )
 
   test('selective exports omit a procedural kind without changing the live scene or later exports', () => {
     const restoreRegistry = nodeRegistry._snapshot()
@@ -2373,29 +2372,32 @@ describe('plugin bake policies through export', () => {
   test.each([
     ['sync', 'meadow-bake', ['bakeGeometry']],
     ['async', 'meadow-bake-async', ['bakeGeometryAsync']],
-  ] as const)('%s export strips, replaces and keeps static plugin kinds without touching the live tree', async (mode, bakedName, expectedCalls) => {
-    await withBakePlugin([pluginId], async ({ root, live, nodes, calls }) => {
-      const prepared =
-        mode === 'sync'
-          ? prepareSceneForExport(root, nodes)
-          : await prepareSceneForExportAsync(root, nodes)
-      try {
-        const scene = prepared.scene
-        expect(scene.getObjectByName(overlayId)).toBeUndefined()
-        expect(scene.getObjectByName(`${overlayId}-live`)).toBeUndefined()
+  ] as const)(
+    '%s export strips, replaces and keeps static plugin kinds without touching the live tree',
+    async (mode, bakedName, expectedCalls) => {
+      await withBakePlugin([pluginId], async ({ root, live, nodes, calls }) => {
+        const prepared =
+          mode === 'sync'
+            ? prepareSceneForExport(root, nodes)
+            : await prepareSceneForExportAsync(root, nodes)
+        try {
+          const scene = prepared.scene
+          expect(scene.getObjectByName(overlayId)).toBeUndefined()
+          expect(scene.getObjectByName(`${overlayId}-live`)).toBeUndefined()
 
-        const meadow = scene.getObjectByName(meadowId)
-        expect(meadow?.getObjectByName(bakedName)).toBeDefined()
-        expect(meadow?.getObjectByName(`${meadowId}-live`)).toBeUndefined()
+          const meadow = scene.getObjectByName(meadowId)
+          expect(meadow?.getObjectByName(bakedName)).toBeDefined()
+          expect(meadow?.getObjectByName(`${meadowId}-live`)).toBeUndefined()
 
-        expect(scene.getObjectByName(rockId)?.getObjectByName(`${rockId}-live`)).toBeDefined()
-        expect(calls).toEqual([...expectedCalls])
-        expectLiveTreeUntouched(live)
-      } finally {
-        prepared.dispose()
-      }
-    })
-  })
+          expect(scene.getObjectByName(rockId)?.getObjectByName(`${rockId}-live`)).toBeDefined()
+          expect(calls).toEqual([...expectedCalls])
+          expectLiveTreeUntouched(live)
+        } finally {
+          prepared.dispose()
+        }
+      })
+    },
+  )
 
   test('an uninstalled plugin contributes nothing to the export', async () => {
     await withBakePlugin([], async ({ root, live, nodes, calls }) => {
@@ -2436,3 +2438,26 @@ test('prepared exports preserve surface identities and IFC subpart roles on regi
   expect(exported.userData.pascalIfcRole).toBe('railing')
   expect(exported.userData.pascalIfcParts).toEqual([{ start: 0, count: 3, role: 'handrail' }])
 })
+
+test('exports a plugin LOD once without invoking its argument-requiring constructor', () => {
+  class PluginLOD extends THREE.LOD {
+    constructor(model: THREE.Mesh) {
+      super()
+      if (!model) throw new Error('Model is required')
+      this.addLevel(model, 0)
+      this.addLevel(model.clone(), 10)
+    }
+  }
+  const mesh = new THREE.Mesh(new THREE.BoxGeometry(), new THREE.MeshBasicMaterial())
+  const lod = new PluginLOD(mesh)
+  const root = new THREE.Group()
+  root.add(lod)
+  const { scene } = prepareSceneForExport(root, {})
+  const meshes: THREE.Mesh[] = []
+  scene.traverse((object) => {
+    if (object instanceof THREE.Mesh) meshes.push(object)
+  })
+  expect(meshes).toHaveLength(2)
+  expect(meshes[0]!.geometry).not.toBe(mesh.geometry)
+  expect(lod.levels).toHaveLength(2)
+})

package/src/lib/glb-export.ts

@@ -903,7 +903,10 @@ function cloneSceneForExport(
 ): THREE.Object3D {
   if (excludedObjects.has(source)) return new THREE.Group()
 
-  const clone = source.clone(false)
+  // LOD.copy clones every level even when called through clone(false). Export
+  // walks the children itself, and plugin LOD constructors may require inputs.
+  const clone =
+    source instanceof THREE.LOD ? new THREE.Group().copy(source, false) : source.clone(false)
   clone.userData = cloneExportUserData(source.userData)
   const renderable = source as THREE.Mesh
   const renderableClone = clone as THREE.Mesh

package/src/lib/history.test.ts

@@ -109,11 +109,10 @@ describe('standalone history source invalidation', () => {
     `)
   })
 
-  test.each([
-    true,
-    false,
-  ])('discarded preview neighbours rebuild after undo/redo (joined: %s)', (joined) => {
-    runSourceHistoryTest(`
+  test.each([true, false])(
+    'discarded preview neighbours rebuild after undo/redo (joined: %s)',
+    (joined) => {
+      runSourceHistoryTest(`
       const react = await importShared('react')
       mockShared('react', () => ({ ...react, useEffect: () => {} }))
       const frames = []
@@ -152,7 +151,8 @@ describe('standalone history source invalidation', () => {
         assert.deepEqual(Array.from(b.geometry.getAttribute('position').array), canonical)
       }
     `)
-  })
+    },
+  )
 
   test('opening reparent dirties old and new walls on undo and redo', () => {
     runSourceHistoryTest(`
@@ -343,7 +343,12 @@ describe('standalone history source invalidation', () => {
       mockShared('react', () => ({ ...react, useEffect: () => {}, useRef: current => ({ current }) }))
       const frames = []
       const fiber = await importShared('@react-three/fiber')
-      mockShared('@react-three/fiber', () => ({ ...fiber, useFrame: frame => frames.push(frame) }))
+      // DoorSystem and WindowSystem register their materials for scene capture through useThree.
+      mockShared('@react-three/fiber', () => ({
+        ...fiber,
+        useFrame: frame => frames.push(frame),
+        useThree: select => select({ scene: {} }),
+      }))
       const selector = store => Object.assign(fn => fn(store.getState()), store)
       mockShared('@pascal-app/core', () => ({ ...core, useScene: selector(scene), useLiveNodeOverrides: selector(overrides) }))
       const viewer = await importShared('@pascal-app/viewer')

package/src/lib/interaction/scope.ts

@@ -111,6 +111,10 @@ export type InteractionScope =
   // (`resolveOverlayPolicy`). A brush that only claimed the scope between
   // pointer-down and -up would flicker all of that back on between dabs.
   | { kind: 'sculpting' }
+  // Point and ask: the pointer belongs to pointing at things for the agent, so selection, handles and
+  // the floating action menu step back (the same active policy as a brush) for as long as the mode
+  // is on. Held by the point-ask session, which leaves the mode if another interaction takes over.
+  | { kind: 'pointing' }
 
 export type InteractionKind = InteractionScope['kind']
 

package/src/lib/level-selection.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BuildingNode,
+  LevelNode,
+  RoofNode,
+  useScene,
+  WallNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { selectPlacedNode } from './level-selection'
+
+// A roof drawn over the ground floor's walls lands on the Roof level, which the editor hides while
+// the ground floor is selected: selecting the roof there alone left it out of sight.
+const BUILDING = 'building_select' as BuildingNode['id']
+const GROUND = 'level_ground' as LevelNode['id']
+
+beforeEach(() => {
+  const ground = LevelNode.parse({ id: GROUND, parentId: BUILDING, level: 0, children: ['wall_a'] })
+  const wall = WallNode.parse({ id: 'wall_a', parentId: GROUND, start: [0, 0], end: [4, 0] })
+  const roofLevel = LevelNode.parse({
+    id: 'level_roof',
+    parentId: BUILDING,
+    level: 1,
+    children: ['roof_main'],
+    metadata: { role: 'roof' },
+  })
+  const roof = RoofNode.parse({ id: 'roof_main', parentId: roofLevel.id })
+  const building = BuildingNode.parse({ id: BUILDING, children: [GROUND, roofLevel.id] })
+  useScene.setState({
+    nodes: Object.fromEntries(
+      [building, ground, wall, roofLevel, roof].map((node) => [node.id, node as AnyNode]),
+    ),
+    rootNodeIds: [BUILDING],
+  } as never)
+  useViewer.getState().setSelection({ buildingId: BUILDING, levelId: GROUND })
+})
+
+describe('selectPlacedNode', () => {
+  test('a node placed on another level is selected with its level', () => {
+    selectPlacedNode('roof_main' as AnyNodeId)
+    expect(useViewer.getState().selection).toMatchObject({
+      buildingId: BUILDING,
+      levelId: 'level_roof',
+      selectedIds: ['roof_main'],
+    })
+  })
+
+  test('a node placed on the level in view leaves the level as it is', () => {
+    selectPlacedNode('wall_a' as AnyNodeId)
+    expect(useViewer.getState().selection).toMatchObject({
+      levelId: GROUND,
+      selectedIds: ['wall_a'],
+    })
+  })
+})