@pascal-app/editor 1.0.0 → 1.0.1

package/src/components/viewer/viewer-units-panel.tsx

@@ -0,0 +1,116 @@
+'use client'
+
+import {
+  type AnyNode,
+  buildUnitReport,
+  type LevelNode,
+  type UnitKind,
+  type UnitNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useMemo } from 'react'
+import { getAreaUnitLabel, squareMetersToAreaUnit } from '../../lib/measurements'
+import { cn } from '../../lib/utils'
+
+const UNIT_KIND_LABELS: Record<UnitKind, string> = {
+  apartment: 'Apartment',
+  'hotel-room': 'Hotel room',
+  commercial: 'Commercial',
+  common: 'Common',
+}
+
+type UnitRow = {
+  unit: UnitNode
+  zoneCount: number
+  areaM2: number
+  /** Levels carrying member zones, lowest ordinal first. */
+  levelIds: LevelNode['id'][]
+}
+
+/**
+ * Read-only unit list shared by the editor preview and the published viewer.
+ * Clicking a row focuses the unit and reveals a member floor through the shared
+ * `useViewer.selection`; a second click clears the focus. Hidden without units.
+ */
+export function ViewerUnitsPanel({ nodes }: { nodes: Readonly<Record<string, AnyNode>> }) {
+  const focusedUnitId = useViewer((s) => s.focusedUnitId)
+  const areaUnit = useViewer((s) => s.unit)
+
+  const rows = useMemo<UnitRow[]>(
+    () =>
+      Object.values(nodes)
+        .filter((node): node is UnitNode => node.type === 'unit')
+        .map((unit) => {
+          const report = buildUnitReport(unit, nodes)
+          const ordinals = new Map<LevelNode['id'], number>()
+          for (const member of report.members) {
+            if (member.levelId && member.levelOrdinal !== null) {
+              ordinals.set(member.levelId, member.levelOrdinal)
+            }
+          }
+          return {
+            unit,
+            zoneCount: report.memberCount,
+            areaM2: report.grossAreaM2,
+            levelIds: [...ordinals.entries()].sort((a, b) => a[1] - b[1]).map(([id]) => id),
+          }
+        }),
+    [nodes],
+  )
+
+  if (rows.length === 0) return null
+
+  return (
+    <div className="corner-smooth pointer-events-auto flex w-48 flex-col overflow-hidden rounded-2xl border border-border/40 bg-background/95 py-1 shadow-elevation-4 backdrop-blur-xl">
+      <span className="px-3 py-2 font-medium text-[10px] text-muted-foreground uppercase tracking-wider">
+        Units
+      </span>
+      <div className="flex flex-col">
+        {rows.map((row) => {
+          const isFocused = row.unit.id === focusedUnitId
+          const area = Math.round(squareMetersToAreaUnit(row.areaM2, areaUnit))
+          const details = `${UNIT_KIND_LABELS[row.unit.kind]} · ${row.zoneCount} ${row.zoneCount === 1 ? 'zone' : 'zones'} · ${area} ${getAreaUnitLabel(areaUnit)}`
+          return (
+            <button
+              className={cn(
+                'group/row relative flex w-full cursor-pointer select-none items-center border-border/50 border-r border-r-transparent border-b px-3 py-1.5 text-sm transition-all duration-200',
+                isFocused
+                  ? 'border-r-3 border-r-white bg-accent/50 text-foreground'
+                  : 'text-muted-foreground hover:bg-accent/30 hover:text-foreground',
+              )}
+              key={row.unit.id}
+              onClick={() => {
+                const viewer = useViewer.getState()
+                if (isFocused) {
+                  viewer.setFocusedUnit(null)
+                  return
+                }
+                viewer.setFocusedUnit(row.unit.id)
+                // Same rule as the editor: keep the current floor when it
+                // already carries a member zone, otherwise reveal the lowest one.
+                const current = viewer.selection.levelId
+                const levelId =
+                  current && row.levelIds.includes(current) ? current : row.levelIds[0]
+                if (levelId && levelId !== current) viewer.setSelection({ levelId })
+              }}
+              type="button"
+            >
+              <div className="flex min-w-0 flex-1 items-center gap-2">
+                <span className="flex h-4 w-4 shrink-0 items-center justify-center">
+                  <span
+                    className="h-2.5 w-2.5 rounded-full"
+                    style={{ backgroundColor: row.unit.color }}
+                  />
+                </span>
+                <div className="min-w-0 flex-1 text-left">
+                  <div className="truncate">{row.unit.name}</div>
+                  <div className="truncate text-[11px] text-muted-foreground">{details}</div>
+                </div>
+              </div>
+            </button>
+          )
+        })}
+      </div>
+    </div>
+  )
+}

package/src/hooks/use-ceiling-events.test.ts

@@ -7,6 +7,7 @@ import {
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
+import { ProceduralItemNode, shelfRecipe } from '@pascal-app/core/procedural-items'
 import { hideFromScene, showInScene, useViewer } from '@pascal-app/viewer'
 import { _roots, act, createRoot } from '@react-three/fiber'
 import { createElement } from 'react'
@@ -18,11 +19,16 @@ import {
   type WebGLRenderer,
 } from 'three'
 import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
 import { useCeilingEvents } from './use-ceiling-events'
 
-test('ceiling-item placement keeps move and commit hits while an unhovered ceiling is batched', async () => {
+test.each([
+  'item',
+  'procedural-item',
+])('%s ceiling placement keeps move and commit hits while an unhovered ceiling is batched', async (kind) => {
   const previousViewer = useViewer.getState()
   const previousEditor = useEditor.getState()
+  const previousInteraction = useInteractionScope.getState()
   const previousScene = useScene.getState()
   const actGlobal = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
   const previousAct = actGlobal.IS_REACT_ACT_ENVIRONMENT
@@ -73,7 +79,22 @@ test('ceiling-item placement keeps move and commit hits while an unhovered ceili
       cameraDragging: false,
       selection: { buildingId: null, levelId: level.id, zoneId: null, selectedIds: [] },
     })
-    useEditor.setState({ selectedItem: { attachTo: 'ceiling' } as never })
+    if (kind === 'item') useEditor.setState({ selectedItem: { attachTo: 'ceiling' } as never })
+    else {
+      useEditor.setState({ selectedItem: null })
+      useEditor.getState().setMovingNode(
+        ProceduralItemNode.parse({
+          recipe: {
+            ...shelfRecipe,
+            mounting: { attachTo: 'ceiling', reference: 'top' },
+            surfaces: [
+              { id: 'top', label: 'Top', position: [0, 'height', 0], size: ['width', 'depth'] },
+            ],
+          },
+          parentId: ceiling.id,
+        }) as never,
+      )
+    }
     await root.configure({
       gl: {
         domElement: canvas,
@@ -116,6 +137,7 @@ test('ceiling-item placement keeps move and commit hits while an unhovered ceili
     surface.material.dispose()
     useScene.setState(previousScene)
     useEditor.setState(previousEditor)
+    useInteractionScope.setState(previousInteraction)
     useViewer.setState(previousViewer)
     actGlobal.IS_REACT_ACT_ENVIRONMENT = previousAct
   }

package/src/hooks/use-ceiling-events.ts

@@ -7,6 +7,7 @@ import {
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
+import { isProceduralItem } from '@pascal-app/core/procedural-items'
 import { useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect, useRef } from 'react'
@@ -61,7 +62,10 @@ export function useCeilingEvents() {
       const ed = useEditor.getState()
       if (ed.selectedItem?.attachTo === 'ceiling') return true
       const moving = getMovingNode()
-      return moving?.type === 'item' && moving.asset?.attachTo === 'ceiling'
+      return (
+        (moving?.type === 'item' && moving.asset?.attachTo === 'ceiling') ||
+        (isProceduralItem(moving) && moving.recipe.mounting?.attachTo === 'ceiling')
+      )
     }
 
     type Hit = { node: CeilingNode; mesh: Object3D; world: Vector3; local: Vector3 }

package/src/hooks/use-keyboard.ts

@@ -32,6 +32,7 @@ import { isActive } from '../lib/interaction/scope'
 import { copySelectedNodesToEditorClipboard } from '../lib/scene-clipboard'
 import { sfxEmitter } from '../lib/sfx-bus'
 import { activeSiteNode, clampBrushRadius } from '../lib/terrain-sculpt'
+import { leaveUnitFocus } from '../lib/units'
 import { toggleWindowOpenState } from '../lib/window-interaction'
 import useDeleteConfirmation from '../store/use-delete-confirmation'
 import useEditor, { getActiveContinuationContext, getActiveSnapContext } from '../store/use-editor'
@@ -390,7 +391,8 @@ export const useKeyboard = ({
         // Only switch to select mode if no tool had an active mid-action to cancel.
         // (e.g. mid-wall draw or mid-slab polygon should only cancel the action, not exit the tool)
         if (!_toolCancelConsumed) {
-          exitToSelectAfterUnconsumedCancel()
+          if (leaveUnitFocus()) useEditor.getState().armToolMode({ mode: 'select' })
+          else exitToSelectAfterUnconsumedCancel()
         }
       } else if (e.key === '1' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()

package/src/index.tsx

@@ -137,6 +137,7 @@ export {
   type PlacementCoordinatorConfig,
   usePlacementCoordinator,
 } from './components/tools/item/use-placement-coordinator'
+export { MoveRegistryNodeTool } from './components/tools/registry/move-registry-node-tool'
 export { useRegistryToolContext } from './components/tools/registry-tool-context'
 export { CursorSphere } from './components/tools/shared/cursor-sphere'
 export { DragBoundingBox } from './components/tools/shared/drag-bounding-box'
@@ -317,6 +318,7 @@ export {
   ViewerStageSwitcher,
   type ViewerStageSwitcherProps,
 } from './components/viewer/viewer-stage-switcher'
+export { ViewerUnitsPanel } from './components/viewer/viewer-units-panel'
 export {
   WalkthroughHud,
   type WalkthroughHudProps,
@@ -378,6 +380,7 @@ export {
   resolveElevatorSupportLevelId,
   resolveElevatorSupportY,
 } from './lib/elevator-support'
+export type { ExportTextureUtils } from './lib/export-texture-utils'
 export { getFloatingMenuScale } from './lib/floating-menu-scale'
 // Floor-plan stair helpers — the cumulative-transform walk
 // (`computeFloorplanStairSegmentTransforms`) and the rich segment-entry
@@ -544,6 +547,8 @@ export {
   editorHostPanelRegistry,
   registerEditorHostPanel,
 } from './lib/plugin-panels'
+export { configureManifoldRuntime } from './lib/print-shell-compiler-manifold-worker'
+export type { ManifoldRuntimeOptions } from './lib/print-shell-compiler-protocol'
 export {
   createQuickMeasurementPointerScheduler,
   quickMeasurementContext,

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

@@ -0,0 +1,167 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import * as THREE from 'three'
+import type { WebGPURenderer } from 'three/webgpu'
+import { createExportTextureUtils } from './export-texture-utils'
+
+const globals = globalThis as unknown as { document?: unknown }
+const previousDocument = globals.document
+
+type FakeRenderer = {
+  renderer: WebGPURenderer
+  calls: { render: number; dispose: number; destroy: number; sizes: [number, number][] }
+  domElement: object
+}
+
+function fakeRenderer(): FakeRenderer {
+  const calls = { render: 0, dispose: 0, destroy: 0, sizes: [] as [number, number][] }
+  const domElement = { kind: 'renderer-canvas' }
+  const renderer = {
+    domElement,
+    outputColorSpace: THREE.SRGBColorSpace,
+    backend: {
+      device: {
+        destroy: () => {
+          calls.destroy += 1
+        },
+      },
+    },
+    setSize: (width: number, height: number) => {
+      calls.sizes.push([width, height])
+    },
+    render: () => {
+      calls.render += 1
+    },
+    dispose: async () => {
+      calls.dispose += 1
+    },
+  }
+  return { renderer: renderer as unknown as WebGPURenderer, calls, domElement }
+}
+
+function installCanvasDocument(drawn: object[]) {
+  globals.document = {
+    createElement: (tagName: string) => {
+      if (tagName !== 'canvas') throw new Error(`Unexpected element request: ${tagName}`)
+      return {
+        width: 0,
+        height: 0,
+        getContext: () => ({
+          drawImage: (source: object) => {
+            drawn.push(source)
+          },
+        }),
+      }
+    },
+  }
+}
+
+function compressedTexture(name: string, width = 8, height = 4): THREE.CompressedTexture {
+  const texture = new THREE.CompressedTexture([], width, height)
+  texture.name = name
+  texture.colorSpace = THREE.NoColorSpace
+  texture.wrapS = THREE.RepeatWrapping
+  texture.wrapT = THREE.MirroredRepeatWrapping
+  texture.minFilter = THREE.NearestFilter
+  texture.magFilter = THREE.NearestFilter
+  return texture
+}
+
+afterEach(() => {
+  globals.document = previousDocument
+})
+
+describe('createExportTextureUtils', () => {
+  test('starts one renderer for every compressed texture in the export and releases it once', async () => {
+    const drawn: object[] = []
+    installCanvasDocument(drawn)
+    const fake = fakeRenderer()
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fake.renderer
+    })
+
+    const readable = await Promise.all([
+      utils.decompress(compressedTexture('NormalGL_a')),
+      utils.decompress(compressedTexture('Color_b', 16, 16)),
+      utils.decompress(compressedTexture('Rough_c', 2, 8)),
+    ])
+
+    expect(starts).toBe(1)
+    expect(fake.calls.render).toBe(3)
+    expect(fake.calls.sizes).toEqual([
+      [8, 4],
+      [16, 16],
+      [2, 8],
+    ])
+    expect(drawn).toEqual([fake.domElement, fake.domElement, fake.domElement])
+    expect(fake.renderer.outputColorSpace).toBe(THREE.SRGBColorSpace)
+
+    const first = readable[0] as THREE.CanvasTexture
+    expect(first.isCanvasTexture).toBe(true)
+    expect(first.name).toBe('NormalGL_a')
+    expect(first.colorSpace).toBe(THREE.NoColorSpace)
+    expect(first.wrapS).toBe(THREE.RepeatWrapping)
+    expect(first.wrapT).toBe(THREE.MirroredRepeatWrapping)
+    expect(first.minFilter).toBe(THREE.NearestFilter)
+    expect(first.magFilter).toBe(THREE.NearestFilter)
+
+    await utils.dispose()
+    await utils.dispose()
+    expect(fake.calls.dispose).toBe(1)
+    expect(fake.calls.destroy).toBe(1)
+  })
+
+  test('clamps the readback to maxTextureSize', async () => {
+    installCanvasDocument([])
+    const fake = fakeRenderer()
+    const utils = createExportTextureUtils(async () => fake.renderer)
+
+    const readable = await utils.decompress(compressedTexture('Color', 4096, 1024), 2048)
+
+    expect(fake.calls.sizes).toEqual([[2048, 1024]])
+    expect((readable.image as { width: number; height: number }).width).toBe(2048)
+    await utils.dispose()
+  })
+
+  test('rejects when no GPU renderer can start instead of leaving the export pending', async () => {
+    installCanvasDocument([])
+    const utils = createExportTextureUtils(async () => {
+      throw new Error('no adapter')
+    })
+
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('no adapter')
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('no adapter')
+    await expect(utils.dispose()).resolves.toBeUndefined()
+  })
+
+  test('disposing without decompressing never starts a renderer', async () => {
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fakeRenderer().renderer
+    })
+
+    await utils.dispose()
+    expect(starts).toBe(0)
+  })
+
+  test('a decompress after dispose rejects instead of starting an unowned renderer', async () => {
+    installCanvasDocument([])
+    const fake = fakeRenderer()
+    let starts = 0
+    const utils = createExportTextureUtils(async () => {
+      starts += 1
+      return fake.renderer
+    })
+
+    await utils.decompress(compressedTexture('Color'))
+    await utils.dispose()
+    await expect(utils.decompress(compressedTexture('Color'))).rejects.toThrow('abandoned')
+    await utils.dispose()
+
+    expect(starts).toBe(1)
+    expect(fake.calls.dispose).toBe(1)
+    expect(fake.calls.destroy).toBe(1)
+  })
+})

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>
+}