@pascal-app/editor 1.0.0-beta.4 → 1.0.0

package/src/lib/selection-routing.ts

@@ -1,15 +1,22 @@
 import {
   type AnyNode,
+  type AnyNodeId,
   emitter,
   type ItemNode,
   nodeRegistry,
   resolveSelectionProxyId,
+  useScene,
 } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+import { emitDeleteSFX } from './sfx-bus'
 
 export type SelectionModifierKeys = {
   meta: boolean
   ctrl: boolean
   shift: boolean
+  /** Alt alone: select one session-group member without expanding. */
+  alt: boolean
 }
 
 export type NodeSelectionTarget = {
@@ -18,6 +25,20 @@ export type NodeSelectionTarget = {
 }
 
 export function emitCanvasNodeSelection(node: AnyNode): void {
+  if (useEditor.getState().mode === 'delete') {
+    const scene = useScene.getState()
+    if (scene.readOnly) return
+
+    emitDeleteSFX(node.type)
+    scene.deleteNode(node.id as AnyNodeId)
+    if (node.parentId) scene.dirtyNodes.add(node.parentId as AnyNodeId)
+    useViewer.getState().setSelection({ selectedIds: [] })
+    if (useViewer.getState().hoveredId === node.id) {
+      useViewer.setState({ hoveredId: null })
+    }
+    return
+  }
+
   emitter.emit('selection:canvas-node-click', node)
 }
 
@@ -59,17 +80,19 @@ export function selectionModifiersFromEvent(
     metaKey?: boolean
     ctrlKey?: boolean
     shiftKey?: boolean
+    altKey?: boolean
     nativeEvent?: {
       metaKey?: boolean
       ctrlKey?: boolean
       shiftKey?: boolean
+      altKey?: boolean
     }
   } | null,
   fallback?: Partial<SelectionModifierKeys>,
 ): SelectionModifierKeys {
   const fromEvent = (
     key: keyof SelectionModifierKeys,
-    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey',
+    eventKey: 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey',
   ) => {
     if (typeof event?.[eventKey] === 'boolean') return event[eventKey]
     if (typeof event?.nativeEvent?.[eventKey] === 'boolean') return event.nativeEvent[eventKey]
@@ -80,6 +103,7 @@ export function selectionModifiersFromEvent(
     meta: fromEvent('meta', 'metaKey'),
     ctrl: fromEvent('ctrl', 'ctrlKey'),
     shift: fromEvent('shift', 'shiftKey'),
+    alt: fromEvent('alt', 'altKey'),
   }
 }
 
@@ -88,11 +112,14 @@ export function resolveSelectedIdsForNodeClick({
   currentSelectedIds,
   modifierKeys,
   nodeId,
+  expandIdsForNode,
 }: {
   baseSelectedIds?: readonly string[]
   currentSelectedIds: readonly string[]
   modifierKeys: SelectionModifierKeys
   nodeId: string
+  /** Session-group expand on plain click (not on modifier/Alt). */
+  expandIdsForNode?: (nodeId: string) => string[] | null
 }): string[] {
   if (isSelectionModifierActive(modifierKeys)) {
     const selectedIds = baseSelectedIds ?? currentSelectedIds
@@ -102,6 +129,12 @@ export function resolveSelectedIdsForNodeClick({
     return [...selectedIds, nodeId]
   }
 
+  if (modifierKeys.alt) {
+    return [nodeId]
+  }
+
+  const expanded = expandIdsForNode?.(nodeId)
+  if (expanded && expanded.length > 1) return expanded
   return [nodeId]
 }
 

package/src/lib/session-groups.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  canCreateSessionGroup,
+  createSessionGroup,
+  expandSessionGroupMembers,
+  liveSessionGroups,
+  nextSessionGroupId,
+  resetSessionGroupIdSerial,
+  type SessionSelectionGroup,
+  selectionIntersectsSessionGroup,
+  selectionMatchesSessionGroup,
+  ungroupSessionSelection,
+} from './session-groups'
+
+function group(id: string, memberIds: string[], label = id): SessionSelectionGroup {
+  return { id, memberIds, label }
+}
+
+describe('session-groups', () => {
+  test('createSessionGroup requires two live members', () => {
+    resetSessionGroupIdSerial()
+    expect(
+      createSessionGroup([], ['a'], { idFactory: () => 'g1', labelFactory: () => 'G1' }).created,
+    ).toBeNull()
+  })
+
+  test('create and expand and ungroup', () => {
+    resetSessionGroupIdSerial(0)
+    const { groups, created } = createSessionGroup([], ['a', 'b', 'c'], {
+      idFactory: () => 'g1',
+      labelFactory: () => 'Group 1',
+    })
+    expect(created?.memberIds).toEqual(['a', 'b', 'c'])
+    expect(expandSessionGroupMembers(groups, 'b')).toEqual(['b', 'a', 'c'])
+    expect(selectionMatchesSessionGroup(groups, ['a', 'b', 'c'])?.label).toBe('Group 1')
+    expect(canCreateSessionGroup(groups, ['a', 'b', 'c'])).toBe(false)
+    expect(canCreateSessionGroup(groups, ['a', 'b'])).toBe(true)
+    expect(ungroupSessionSelection(groups, ['a']).groups).toEqual([])
+  })
+
+  test('liveSessionGroups hides groups that fall under two live members', () => {
+    resetSessionGroupIdSerial(0)
+    expect(nextSessionGroupId()).toBe('session-group-1')
+    expect(liveSessionGroups([group('g1', ['a', 'gone'])], new Set(['a']))).toEqual([])
+    expect(liveSessionGroups([group('g1', ['a', 'b', 'gone'])], new Set(['a', 'b']))).toEqual([
+      group('g1', ['a', 'b']),
+    ])
+    expect(selectionIntersectsSessionGroup([group('g1', ['a', 'b'])], ['b'])).toBe(true)
+  })
+
+  test('a deleted member is excluded from reads but kept in membership for undo', () => {
+    const groups = [group('g1', ['a', 'b', 'c'], 'Suite')]
+
+    // `a` deleted: reads narrow to the survivors...
+    expect(expandSessionGroupMembers(groups, 'b', new Set(['b', 'c']))).toEqual(['b', 'c'])
+    // ...and `a` and `b` deleted drops the group below the floor, so it goes inert.
+    expect(expandSessionGroupMembers(groups, 'c', new Set(['c']))).toBeNull()
+    expect(selectionIntersectsSessionGroup(groups, ['c'], new Set(['c']))).toBe(false)
+
+    // Undo restores the nodes, and membership was never rewritten — so the whole
+    // group comes back. A destructive prune would have lost `a` (or the group).
+    expect(expandSessionGroupMembers(groups, 'a', new Set(['a', 'b', 'c']))).toEqual([
+      'a',
+      'b',
+      'c',
+    ])
+  })
+
+  test('ungroup leaves inert groups alone so undo can revive them', () => {
+    const groups = [group('g1', ['a', 'b'], 'Pair')]
+    // Only `a` is live, so the group is invisible to the user — Ctrl+Shift+G on
+    // `a` must not dissolve what it cannot see.
+    const result = ungroupSessionSelection(groups, ['a'], new Set(['a']))
+    expect(result.dissolved).toEqual([])
+    expect(result.groups).toEqual(groups)
+  })
+
+  test('grouping a member of an existing group dissolves that group whole', () => {
+    resetSessionGroupIdSerial(0)
+    const groups = [group('g1', ['a', 'b', 'c'], 'Suite')]
+    const { groups: next, created } = createSessionGroup(groups, ['c', 'd'], {
+      idFactory: () => 'g2',
+      labelFactory: () => 'Group 2',
+    })
+    expect(created?.memberIds).toEqual(['c', 'd'])
+    expect(next).toEqual([group('g2', ['c', 'd'], 'Group 2')])
+  })
+})

package/src/lib/session-groups.ts

@@ -0,0 +1,201 @@
+/**
+ * Pure helpers for editor-only session selection groups.
+ * Not scene-graph nodes; not saved with the project.
+ * Ctrl/Cmd+G creates, Ctrl/Cmd+Shift+G dissolves; plain click expands.
+ *
+ * Stored membership is never rewritten to drop deleted nodes — `liveIds`
+ * filtering happens on every read instead. A destructive prune would make
+ * delete-then-undo lose the restored node's group, and would drop the group
+ * outright once it fell under the two-member floor.
+ */
+
+export type SessionSelectionGroup = {
+  id: string
+  memberIds: readonly string[]
+  label: string
+}
+
+export type SessionGroupIdFactory = () => string
+
+let sessionGroupSerial = 0
+
+export function nextSessionGroupId(): string {
+  sessionGroupSerial += 1
+  return `session-group-${sessionGroupSerial}`
+}
+
+export function nextSessionGroupLabel(): string {
+  return `Group ${Math.max(1, sessionGroupSerial)}`
+}
+
+export function resetSessionGroupIdSerial(value = 0): void {
+  sessionGroupSerial = value
+}
+
+function uniquePreserveOrder(ids: readonly string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const id of ids) {
+    if (!id || seen.has(id)) continue
+    seen.add(id)
+    out.push(id)
+  }
+  return out
+}
+
+function isLive(id: string, liveIds?: ReadonlySet<string> | null): boolean {
+  if (!liveIds) return true
+  return liveIds.has(id)
+}
+
+function withLabel(
+  group: SessionSelectionGroup,
+  memberIds: readonly string[],
+): SessionSelectionGroup {
+  return {
+    id: group.id,
+    label: group.label || 'Group',
+    memberIds,
+  }
+}
+
+function liveMembers(group: SessionSelectionGroup, liveIds?: ReadonlySet<string> | null): string[] {
+  return uniquePreserveOrder(group.memberIds.filter((id) => isLive(id, liveIds)))
+}
+
+/**
+ * Read-time view: groups narrowed to their live members, dropping any that fall
+ * under two. A group below the floor is inert, not gone — deleting members never
+ * touches storage, so undo brings it back.
+ */
+export function liveSessionGroups(
+  groups: readonly SessionSelectionGroup[],
+  liveIds?: ReadonlySet<string> | null,
+): SessionSelectionGroup[] {
+  const next: SessionSelectionGroup[] = []
+  for (const group of groups) {
+    const members = liveMembers(group, liveIds)
+    if (members.length < 2) continue
+    next.push(withLabel(group, members))
+  }
+  return next
+}
+
+export function createSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  memberIds: readonly string[],
+  options?: {
+    liveIds?: ReadonlySet<string> | null
+    idFactory?: SessionGroupIdFactory
+    labelFactory?: () => string
+  },
+): {
+  groups: SessionSelectionGroup[]
+  created: SessionSelectionGroup | null
+  alreadyGrouped: boolean
+} {
+  const liveIds = options?.liveIds
+  const members = uniquePreserveOrder(memberIds.filter((id) => isLive(id, liveIds)))
+  if (members.length < 2) {
+    return { groups: [...groups], created: null, alreadyGrouped: false }
+  }
+
+  const memberSet = new Set(members)
+  const exact = liveSessionGroups(groups, liveIds).find(
+    (group) =>
+      group.memberIds.length === members.length && group.memberIds.every((id) => memberSet.has(id)),
+  )
+  if (exact) {
+    return { groups: [...groups], created: exact, alreadyGrouped: true }
+  }
+
+  // Grouping a selection takes its members out of whatever group they were in,
+  // dissolving that group whole rather than leaving a remnant.
+  const kept = groups.filter((group) => !group.memberIds.some((id) => memberSet.has(id)))
+  const id = (options?.idFactory ?? nextSessionGroupId)()
+  const label =
+    options?.labelFactory?.() ??
+    (options?.idFactory ? `Group ${kept.length + 1}` : nextSessionGroupLabel())
+  const created: SessionSelectionGroup = { id, label, memberIds: members }
+  return { groups: [...kept, created], created, alreadyGrouped: false }
+}
+
+export function ungroupSessionSelection(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): { groups: SessionSelectionGroup[]; dissolved: SessionSelectionGroup[] } {
+  const selected = new Set(selectedIds)
+  if (selected.size === 0) {
+    return { groups: [...groups], dissolved: [] }
+  }
+
+  const kept: SessionSelectionGroup[] = []
+  const dissolved: SessionSelectionGroup[] = []
+  for (const group of groups) {
+    // Only a live-viable group is visible to the user, so only that can be
+    // dissolved. An inert one (members deleted) is left alone for undo.
+    const live = liveMembers(group, liveIds)
+    if (live.length >= 2 && live.some((id) => selected.has(id))) {
+      dissolved.push(withLabel(group, live))
+    } else {
+      kept.push(group)
+    }
+  }
+  return { groups: kept, dissolved }
+}
+
+export function expandSessionGroupMembers(
+  groups: readonly SessionSelectionGroup[],
+  nodeId: string,
+  liveIds?: ReadonlySet<string> | null,
+): string[] | null {
+  if (!nodeId) return null
+  for (const group of groups) {
+    if (!group.memberIds.includes(nodeId)) continue
+    const members = liveMembers(group, liveIds)
+    if (members.length < 2) return null
+    if (members[0] === nodeId) return members
+    return [nodeId, ...members.filter((id) => id !== nodeId)]
+  }
+  return null
+}
+
+export function selectionMatchesSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): SessionSelectionGroup | null {
+  if (selectedIds.length < 2) return null
+  const selected = uniquePreserveOrder(selectedIds.filter((id) => isLive(id, liveIds)))
+  if (selected.length < 2) return null
+  const selectedSet = new Set(selected)
+  for (const group of liveSessionGroups(groups, liveIds)) {
+    if (group.memberIds.length !== selected.length) continue
+    if (group.memberIds.every((id) => selectedSet.has(id))) return group
+  }
+  return null
+}
+
+export function selectionIntersectsSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): boolean {
+  if (selectedIds.length === 0) return false
+  const selected = new Set(selectedIds)
+  for (const group of liveSessionGroups(groups, liveIds)) {
+    if (group.memberIds.some((id) => selected.has(id))) return true
+  }
+  return false
+}
+
+export function canCreateSessionGroup(
+  groups: readonly SessionSelectionGroup[],
+  selectedIds: readonly string[],
+  liveIds?: ReadonlySet<string> | null,
+): boolean {
+  const live = uniquePreserveOrder(selectedIds.filter((id) => isLive(id, liveIds)))
+  if (live.length < 2) return false
+  return selectionMatchesSessionGroup(groups, live, liveIds) === null
+}

package/src/lib/sfx-bus.ts

@@ -27,6 +27,7 @@ type SFXEvents = {
   'sfx:menu-hover': undefined
   'sfx:menu-click': undefined
   'sfx:paint-apply': undefined
+  'sfx:success': undefined
   'sfx:terrain-sculpt-start': TerrainVerb
   'sfx:terrain-sculpt-stop': undefined
 }
@@ -56,6 +57,7 @@ const handleSnapshotCapture = () => playSFX('snapshotCapture')
 const handleMenuHover = () => playSFX('menuHover')
 const handleMenuClick = () => playSFX('menuClick')
 const handlePaintApply = () => playSFX('paintApply')
+const handleSuccess = () => playSFX('success')
 const TERRAIN_LOOP_BY_VERB = {
   raise: 'terrainRaise',
   lower: 'terrainLower',
@@ -86,6 +88,7 @@ export function initSFXBus() {
   sfxEmitter.on('sfx:menu-hover', handleMenuHover)
   sfxEmitter.on('sfx:menu-click', handleMenuClick)
   sfxEmitter.on('sfx:paint-apply', handlePaintApply)
+  sfxEmitter.on('sfx:success', handleSuccess)
   sfxEmitter.on('sfx:terrain-sculpt-start', handleTerrainSculptStart)
   sfxEmitter.on('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
   unsubscribeAudio = useAudio.subscribe(updateSFXVolumes)
@@ -106,6 +109,7 @@ export function disposeSFXBus() {
     sfxEmitter.off('sfx:menu-hover', handleMenuHover)
     sfxEmitter.off('sfx:menu-click', handleMenuClick)
     sfxEmitter.off('sfx:paint-apply', handlePaintApply)
+    sfxEmitter.off('sfx:success', handleSuccess)
     sfxEmitter.off('sfx:terrain-sculpt-start', handleTerrainSculptStart)
     sfxEmitter.off('sfx:terrain-sculpt-stop', handleTerrainSculptStop)
     unsubscribeAudio?.()

package/src/lib/sfx-player.ts

@@ -112,6 +112,14 @@ export const SFX: Record<string, SFXConfig> = {
     volumeRange: [0.85, 1.0],
     minIntervalMs: 60,
   },
+  // A three-second jingle for finishing something, not a click cue. No pitch or
+  // volume jitter — a fanfare that lands a semitone off reads as broken rather
+  // than as varied — and a gap longer than the sound itself, so two milestones
+  // that land together play once instead of phasing over each other.
+  success: {
+    src: '/audios/sfx/success.mp3',
+    minIntervalMs: 3_000,
+  },
 } as const
 
 export type SFXName = keyof typeof SFX

package/src/lib/snapping-mode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
+import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
 import {
   cycleSnappingModeIn,
   DEFAULT_SNAPPING_MODE,
@@ -49,12 +49,24 @@ describe('resolveSnapFlags', () => {
 })
 
 describe('per-context snapping', () => {
-  it('items default to grid with no angle lock', () => {
-    expect(defaultSnappingModeFor('item')).toBe('grid')
+  it('items default to magnetic alignment with no angle lock', () => {
+    expect(defaultSnappingModeFor('item')).toBe('lines')
     expect(snappingModesFor('item')).toEqual(['lines', 'grid', 'off'])
     expect(snappingModesFor('item')).not.toContain('angles')
   })
 
+  it('group moves use the magnetic item context by default', () => {
+    const context = snapContextOf({
+      scope: { kind: 'handle-drag', handle: GROUP_MOVE_DRAG_LABEL },
+      mode: 'select',
+      tool: null,
+      profileOf: () => undefined,
+    })
+
+    expect(context).toBe('item')
+    expect(resolveSnapFlags(defaultSnappingModeFor(context!)).magnetic).toBe(true)
+  })
+
   it('walls default to grid and expose the angle lock; polygons do NOT', () => {
     expect(defaultSnappingModeFor('wall')).toBe('grid')
     expect(defaultSnappingModeFor('polygon')).toBe('grid')
@@ -83,10 +95,17 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     ceiling: 'structural',
     roof: 'structural',
     zone: 'structural',
+    block: 'structural',
   }
   const profileOf = (t: string) => declared[t]
   const profileOfNode = (id: string) =>
-    id === 'cabinet-module_1' ? declared.item : id === 'wall_1' ? declared.wall : undefined
+    id === 'cabinet-module_1'
+      ? declared.item
+      : id === 'wall_1'
+        ? declared.wall
+        : id === 'block_1'
+          ? declared['block']
+          : undefined
   const ctx = (
     scope: {
       kind: string
@@ -95,6 +114,7 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
       nodeId?: string
       tool?: string
       handle?: string
+      operator?: string
     },
     mode = 'select',
     tool: string | null = null,
@@ -115,6 +135,14 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     ).toBeNull()
   })
 
+  it('gives mesh rotation the angle context and other edit operations polygon snapping', () => {
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'translate' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'scale' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'loop-cut' })).toBe('polygon')
+    expect(ctx({ kind: 'mesh-editing', nodeId: 'block_1', operator: 'rotate' })).toBe('wall')
+  })
+
   it('endpoint reshape is angle-bearing (wall); curve + polygon vertex edits are not', () => {
     expect(ctx({ kind: 'reshaping', reshape: 'endpoint' })).toBe('wall')
     expect(ctx({ kind: 'reshaping', reshape: 'curve' })).toBe('polygon')

package/src/lib/snapping-mode.ts

@@ -4,10 +4,9 @@ import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-he
 /**
  * Snapping mode is a single global, user-cyclable control that maps onto the
  * two pre-existing snap knobs (`gridSnapStep` grid snap + `magneticSnap`).
- * The default `'grid'` resolves to the exact pair the editor shipped with
- * before this control existed (grid on, magnetic on), so the default path is
- * behaviourally unchanged — only when a user opts into `'lines'` or `'off'`
- * does any snap math get suppressed.
+ * Each context chooses its own default. Item movement defaults to magnetic
+ * alignment so a picked-up group catches neighboring geometry; grid and off
+ * remain explicit alternatives in the contextual chip.
  */
 export type SnappingMode = 'grid' | 'lines' | 'angles' | 'off'
 
@@ -82,9 +81,9 @@ type SnapModeSet = { modes: SnappingMode[]; default: SnappingMode }
 const SNAP_PROFILES: Record<SnapContext, SnapModeSet> = {
   // Wall / fence drafting + endpoint reshape: direction matters → angle lock.
   wall: { modes: ['grid', 'lines', 'angles', 'off'], default: 'grid' },
-  // Item placement / move: grid by default; lines = magnetic alignment only (no
-  // grid lattice), no angle lock (meaningless for a footprint).
-  item: { modes: ['lines', 'grid', 'off'], default: 'grid' },
+  // Item placement / move: magnetic alignment by default; grid is an explicit
+  // alternative, and angle lock is meaningless for a footprint.
+  item: { modes: ['lines', 'grid', 'off'], default: 'lines' },
   // Structural / surface, no direction to set: slab / ceiling / roof draft+move,
   // whole wall/fence translate, curve reshape, polygon boundary edit. Grid by
   // default, NO angle lock.
@@ -148,6 +147,7 @@ export function snapContextOf(args: {
     nodeId?: string
     tool?: string
     handle?: string
+    operator?: string
   }
   mode: string
   tool: string | null
@@ -166,6 +166,10 @@ export function snapContextOf(args: {
     return 'item'
   }
   switch (scope.kind) {
+    case 'mesh-editing':
+      return scope.nodeId
+        ? contextForProfile(profileOfNode?.(scope.nodeId), scope.operator === 'rotate')
+        : null
     case 'handle-drag':
       if (scope.handle === ROTATE_HANDLE_DRAG_LABEL) return null
       return scope.nodeId ? contextForProfile(profileOfNode?.(scope.nodeId), false) : null

package/src/lib/structured-clone-fallback.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+
+const native = globalThis.structuredClone
+
+afterEach(() => {
+  globalThis.structuredClone = native
+})
+
+async function installFallback() {
+  // Fresh module instance each time — the shim is a module side effect.
+  await import(`./structured-clone-fallback?${Math.random()}`)
+}
+
+describe('structuredClone fallback', () => {
+  test('leaves a native implementation alone', async () => {
+    await installFallback()
+    expect(globalThis.structuredClone).toBe(native)
+  })
+
+  test('installs a JSON-based clone when the global is missing', async () => {
+    // @ts-expect-error — simulating a browser without the global.
+    globalThis.structuredClone = undefined
+    await installFallback()
+
+    const source = { units: [{ factor: 1, id: 'm' }], kind: 'length' }
+    const copy = structuredClone(source)
+
+    expect(copy).toEqual(source)
+    expect(copy).not.toBe(source)
+    expect(copy.units).not.toBe(source.units)
+  })
+
+  test('lets lingo build its registry without the global', async () => {
+    // @ts-expect-error — simulating a browser without the global.
+    globalThis.structuredClone = undefined
+    await installFallback()
+
+    // The actual regression: lingo clones its kind table at module-eval time,
+    // so this import throws on a browser lacking structuredClone.
+    const { parseQuantity } = await import('@pascal-app/lingo')
+    const result = parseQuantity('180cm', { kind: 'length', unit: 'm' })
+    expect(result.ok).toBe(true)
+    if (result.ok) expect(result.quantity.to('m').value).toBeCloseTo(1.8, 6)
+  })
+})

package/src/lib/structured-clone-fallback.ts

@@ -0,0 +1,24 @@
+/**
+ * `@pascal-app/lingo` builds its unit registry at module-eval time, and
+ * `registerKind` deep-copies each kind definition with `structuredClone`. On a
+ * browser without that global (Chromium <98 — reported from Honor Browser 9.8
+ * as `ReferenceError: structuredClone is not defined`) the throw happens while
+ * the module graph is still evaluating, so a component-level guard can never
+ * run in time and the whole editor bundle fails to load.
+ *
+ * This has to be imported for its side effect from the module that pulls lingo
+ * in, so it is installed wherever `@pascal-app/editor` is loaded — the OSS app,
+ * the hosted app, and any npm consumer. An app-level polyfill would only cover
+ * the app that declares it.
+ *
+ * Scoped deliberately narrowly: the kind definitions lingo clones are plain
+ * JSON (strings, numbers, arrays of those), so a JSON round-trip is sufficient
+ * and avoids a dependency. This is NOT a spec-compliant `structuredClone` — it
+ * has no support for Map/Set/Date/ArrayBuffer/cycles and throws a `TypeError`
+ * rather than a `DataCloneError`. Anything needing real structured-clone
+ * semantics must not rely on this shim.
+ */
+if (typeof globalThis.structuredClone !== 'function') {
+  globalThis.structuredClone = (<T>(value: T): T =>
+    JSON.parse(JSON.stringify(value)) as T) as typeof structuredClone
+}

package/src/lib/usdz-export.ts

@@ -0,0 +1,38 @@
+import type { AnyNode } from '@pascal-app/core'
+import type { Object3D } from 'three'
+import { USDZExporter } from 'three/examples/jsm/exporters/USDZExporter.js'
+import * as WebGPUTextureUtils from 'three/examples/jsm/utils/WebGPUTextureUtils.js'
+import { type GlbExportOptions, preparePortableSceneFromViewer } from './glb-export'
+import { createUsdzScene, disposeExportResources } from './portable-export'
+
+export type UsdzExportOptions = Pick<
+  GlbExportOptions,
+  'excludedNodeTypes' | 'includedPresentationIds' | 'onlyVisible' | 'onWarning'
+>
+
+/** Export a native, self-contained USDZ with no glTF conversion fallback. */
+export async function exportSceneToUsdz(
+  sceneGroup: Object3D,
+  nodes: Record<string, AnyNode>,
+  options: UsdzExportOptions = {},
+): Promise<Uint8Array<ArrayBuffer>> {
+  const prepared = await preparePortableSceneFromViewer(sceneGroup, nodes, {
+    ...options,
+    textures: 'embed',
+  })
+  for (const warning of prepared.warnings) options.onWarning?.(warning)
+
+  let scene: Object3D | null = null
+  try {
+    scene = createUsdzScene(prepared.scene)
+    const exporter = new USDZExporter()
+    exporter.textureUtils = WebGPUTextureUtils
+    return await exporter.parseAsync(scene, {
+      onlyVisible: options.onlyVisible ?? true,
+      quickLookCompatible: true,
+    })
+  } finally {
+    if (scene) disposeExportResources(scene, { textures: false })
+    prepared.dispose()
+  }
+}