@pascal-app/editor 1.0.0 → 1.0.3

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

@@ -3,11 +3,24 @@ import {
   type AnyNodeId,
   cloneNodesInto,
   collectSubtree,
+  createSceneApi,
   type DuplicableConfig,
+  getSurfaceProvider,
   nodeRegistry,
+  resolveSurfacePlacement,
+  type SurfaceRejectReason,
   useScene,
 } from '@pascal-app/core'
+import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
+import useInteractionScope from '../store/use-interaction-scope'
+import usePlacementPreview from '../store/use-placement-preview'
 import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
+import {
+  surfaceAttachmentId,
+  surfaceAttachmentUpdates,
+  surfaceFramePose,
+  updateSurfaceNode,
+} from './surface-attachment'
 
 function cleanPlacementMetadata<N extends AnyNode>(node: N): N {
   return {
@@ -27,7 +40,13 @@ function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
 }
 
 export function duplicatesAsFreshSubtree(node: AnyNode): boolean {
-  return duplicableConfigFor(node)?.subtree === true
+  // A surface-local root needs the same attachment lifecycle even without descendants.
+  if (surfaceAttachmentId(node) !== null) return true
+  const policy = duplicableConfigFor(node)?.subtree
+  return (
+    policy === true ||
+    (policy === 'with-children' && 'children' in node && node.children.length > 0)
+  )
 }
 
 /**
@@ -94,54 +113,175 @@ export function createFreshPlacementSubtree(
     parentId,
   })
 
-  useScene
-    .getState()
-    .createNodes(
-      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
-    )
+  scene.applyNodeChanges({
+    create: cloned.nodes.map((node, index) =>
+      index === 0 && parentId ? { node, parentId } : { node },
+    ),
+    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceAttachmentId(subtree.root)),
+  })
 
+  const created = useScene.getState().nodes[cloned.rootId]
+  if (!created) return null
+  useInteractionScope.getState().noteSubtreeCreation(created)
   return cloned.rootId
 }
 
+export function discardFreshPlacementSubtree(rootId: AnyNodeId): void {
+  const scene = useScene.getState()
+  if (!scene.nodes[rootId]) return
+  scene.applyNodeChanges({
+    delete: [rootId],
+    update: surfaceAttachmentUpdates(rootId, null, null),
+  })
+}
+
+function namedSurfaceRejection(
+  root: AnyNode,
+  surfaceId: string | null,
+): SurfaceRejectReason | null {
+  if (surfaceId === null) return null
+  const scene = createSceneApi(useScene)
+  const host = root.parentId ? scene.get(root.parentId as AnyNodeId) : undefined
+  if (!host || !('position' in root) || !Array.isArray(root.rotation)) return 'no-surface'
+  const surface = getSurfaceProvider(host)
+    .surfaces?.(host, { scene })
+    .find((s) => s.id === surfaceId)
+  if (!surface) return 'no-surface'
+  const pose = surfaceFramePose(
+    root.parentId,
+    surfaceId,
+    root as {
+      position: [number, number, number]
+      rotation: [number, number, number]
+    },
+    false,
+  )
+  const capabilities = nodeRegistry.get(root.type)?.capabilities
+  const evaluated = isProceduralItem(root) ? evaluateRecipe(root.recipe, root.parameters) : null
+  const bounds =
+    capabilities?.dragBounds?.(root, scene.nodes()) ??
+    (evaluated
+      ? {
+          size: evaluated.dimensions,
+          center: evaluated.min.map((v, i) => (v + evaluated.max[i]!) / 2) as [
+            number,
+            number,
+            number,
+          ],
+        }
+      : undefined)
+  const size = bounds?.size ??
+    capabilities?.floorPlaced?.footprint?.(root, { nodes: scene.nodes() }).dimensions ?? [0, 0, 0]
+  const center = bounds?.center
+  const localBounds = center
+    ? {
+        min: center.map((value, axis) => value - size[axis]! / 2) as [number, number, number],
+        max: center.map((value, axis) => value + size[axis]! / 2) as [number, number, number],
+      }
+    : undefined
+  let reason: SurfaceRejectReason | null = null
+  const placement = resolveSurfacePlacement({
+    host,
+    surface,
+    childKind: root.type,
+    childId: root.id,
+    childFootprint: {
+      size,
+      rotationY: pose.rotation[1],
+      rotation: pose.rotation,
+      localBounds,
+    },
+    hit: { point: pose.position, normalWorldY: 1 },
+    origin: pose.position,
+    scene,
+    onReject: (value) => {
+      reason = value
+    },
+  })
+  if (!placement) return reason ?? 'no-surface'
+  return null
+}
+
 /**
- * Finalises a fresh catalog/duplicate draft as a single undoable creation.
- *
- * Fresh drafts already exist in the scene so renderers and move tools can
- * preview real geometry. On commit we delete that draft while history is
- * paused, then create a clean clone at the final cursor position with history
- * resumed. Undo therefore removes the placed node instead of resurrecting the
- * hidden draft at its origin.
+ * Replace the draft in one validated write. History already excludes fresh
+ * subtrees, so this records one creation without first deleting the preview.
  */
 export function commitFreshPlacementSubtree(
   rootId: AnyNodeId,
   rootPatch: Partial<AnyNode>,
+  onReject?: (reason: SurfaceRejectReason) => void,
 ): AnyNodeId | null {
   const scene = useScene.getState()
   const subtree = collectSubtree(scene.nodes, rootId)
-  if (!subtree) return null
+  if (!subtree || scene.readOnly) return null
 
-  const root = cleanPlacementMetadata({
-    ...subtree.root,
-    ...rootPatch,
-  } as AnyNode)
+  const root = cleanPlacementMetadata({ ...subtree.root, ...rootPatch } as AnyNode)
+  const surfaceId =
+    root.parentId === subtree.root.parentId ? surfaceAttachmentId(subtree.root) : null
+  const rejection = namedSurfaceRejection(root, surfaceId)
+  if (rejection) {
+    onReject?.(rejection)
+    return null
+  }
   const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
   const parentId = parentIdOf(root)
-  const cloned = cloneNodesInto([root, ...descendants], {
-    rootId,
-    parentId,
-  })
+  const cloned = cloneNodesInto([root, ...descendants], { rootId, parentId })
+  const updates = surfaceAttachmentUpdates(rootId, null, null)
+  for (const update of surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId)) {
+    const attachments = { ...(update.data as { attachments: Record<string, string> }).attachments }
+    delete attachments[rootId]
+    const previous = updates.findIndex((entry) => entry.id === update.id)
+    const merged = { id: update.id, data: { attachments } }
+    if (previous === -1) updates.push(merged)
+    else updates[previous] = merged
+  }
 
+  const scope = useInteractionScope.getState()
+  const factoryCreated =
+    scope.ownedSubtree?.creation.rootId === rootId || scope.pendingSubtree?.rootId === rootId
   const temporal = useScene.temporal.getState()
-  const wasTracking = (temporal as { isTracking?: boolean }).isTracking !== false
-  if (wasTracking) temporal.pause()
-  useScene.getState().deleteNode(rootId)
-  temporal.resume()
-  useScene
-    .getState()
-    .createNodes(
-      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
-    )
-  if (!wasTracking) temporal.pause()
-
+  const wasTracking = temporal.isTracking
+  if (!factoryCreated && descendants.length === 0 && surfaceId === null) {
+    // Preserve the established root-only lifecycle for placements outside the subtree factory.
+    if (wasTracking) temporal.pause()
+    updateSurfaceNode(rootId, {}, null)
+    useScene.getState().deleteNode(rootId)
+    temporal.resume()
+    useScene.getState().applyNodeChanges({
+      create: cloned.nodes.map((node, index) =>
+        index === 0 && parentId ? { node, parentId } : { node },
+      ),
+      update: updates,
+    })
+    if (!wasTracking) temporal.pause()
+  } else {
+    temporal.resume()
+    try {
+      // applyNodeChanges validates the complete proposed graph before publishing any part of it.
+      scene.applyNodeChanges({
+        delete: [rootId],
+        create: cloned.nodes.map((node, index) =>
+          index === 0 && parentId ? { node, parentId } : { node },
+        ),
+        update: updates,
+      })
+      for (const node of [subtree.root, ...subtree.descendants]) scene.clearDirty(node.id)
+    } catch (error) {
+      // Zustand publishes before notifying subscribers. A subscriber error must restore
+      // the draft and its ownership/history, never masquerade as a placement refusal.
+      temporal.pause()
+      try {
+        if (useScene.getState() !== scene) useScene.setState(scene, true)
+      } finally {
+        useInteractionScope.setState(scope)
+        useScene.temporal.setState(temporal)
+      }
+      throw error
+    } finally {
+      if (!wasTracking) temporal.pause()
+    }
+  }
+  useInteractionScope.getState().finishSubtree(rootId)
+  if (usePlacementPreview.getState().node?.id === rootId) usePlacementPreview.getState().clear()
   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',
+    ])
+  })
+})