@pascal-app/editor 1.1.0 → 1.1.1

package/src/components/editor/first-person/terrain-collider.ts

@@ -1,212 +0,0 @@
-/**
- * The sculpted ground as walkthrough collision geometry.
- *
- * The first-person collider world is a single merged BVH mesh, and before terrain
- * the ground contributed one flat 2 km box to it. That box is wrong in both
- * directions on a sculpted site: it holds the player up at the datum inside an
- * excavation, and buries them inside a hill. This module replaces it.
- *
- * Two properties it has to hold, because the whole point is that walking agrees
- * with every other consumer of the field:
- *
- * - **The surface is the field**, sampled at every vertex — the same
- *   `heightAtSample`/`normalAt` the rendered mesh uses (`terrain-geometry.ts`),
- *   so what you see is what you stand on. It is deliberately not a decimated
- *   proxy at realistic field sizes.
- * - **It extends past the field**, because `heightAt` clamps to the border
- *   outside it. A collider that stopped at the field edge would drop the player
- *   into the void one step past the site, which is exactly the bug the flat box
- *   existed to prevent. The skirt extrudes each border sample outward at its own
- *   height, so the collider and `heightAt` agree everywhere, not just inside.
- *
- * Non-indexed triangles with position + normal, matching what the other collider
- * contributors emit — `mergeGeometries` requires every input to agree on both.
- */
-
-import { heightAtSample, normalAt, type TerrainField } from '@pascal-app/core'
-import * as THREE from 'three'
-
-/**
- * How far past the field the ground keeps holding the player, in metres. Matches
- * the flat box's half-extent so a site's collider bounds do not change size when
- * it gains terrain.
- */
-const SKIRT_REACH = 1000
-
-/**
- * Cell budget before the collider decimates.
- *
- * 66k cells is a 257² field — the largest anything realistic produces, and ~131k
- * triangles, which the BVH builds in well under a frame's worth of budget. The
- * schema allows up to 4097² (a decode-bomb guard, not a real terrain); at that
- * size an exact collider would be 100M triangles, so past the budget this steps
- * the sample grid and the collider becomes a faithful-but-coarser version of the
- * same surface rather than an out-of-memory crash.
- */
-const MAX_COLLIDER_CELLS = 66_000
-
-function colliderStride(field: TerrainField): number {
-  const cells = Math.max(1, (field.cols - 1) * (field.rows - 1))
-  if (cells <= MAX_COLLIDER_CELLS) return 1
-  return Math.ceil(Math.sqrt(cells / MAX_COLLIDER_CELLS))
-}
-
-/** The sample indices the collider walks: every `stride`-th, always including the border. */
-function sampleLine(count: number, stride: number): number[] {
-  const line: number[] = []
-  for (let i = 0; i < count - 1; i += stride) line.push(i)
-  line.push(count - 1)
-  return line
-}
-
-type Vertex = { x: number; y: number; z: number }
-
-class TriangleSink {
-  private readonly positions: number[] = []
-  private readonly normals: number[] = []
-
-  constructor(private readonly field: TerrainField) {}
-
-  private push(v: Vertex): void {
-    this.positions.push(v.x, v.y, v.z)
-    const [nx, ny, nz] = normalAt(this.field, v.x, v.z)
-    this.normals.push(nx, ny, nz)
-  }
-
-  /**
-   * One cell, given its four corners named by axis order. Winding matches
-   * `buildTerrainMesh`: `(p00, p01, p10)` and `(p10, p01, p11)` faces +Y, which is
-   * what the spawn resolver's `normal.dot(UP) > 0.2` floor test needs.
-   */
-  quad(p00: Vertex, p10: Vertex, p01: Vertex, p11: Vertex): void {
-    this.push(p00)
-    this.push(p01)
-    this.push(p10)
-    this.push(p10)
-    this.push(p01)
-    this.push(p11)
-  }
-
-  build(): THREE.BufferGeometry | null {
-    if (this.positions.length === 0) return null
-    const geometry = new THREE.BufferGeometry()
-    geometry.setAttribute(
-      'position',
-      new THREE.BufferAttribute(new Float32Array(this.positions), 3),
-    )
-    geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(this.normals), 3))
-    return geometry
-  }
-}
-
-/**
- * Terrain collision geometry in the site's own frame — the caller applies the
- * site's world matrix, exactly as it did for the flat box it replaces.
- */
-export function createTerrainColliderGeometry(field: TerrainField): THREE.BufferGeometry | null {
-  if (field.cols < 2 || field.rows < 2) return null
-
-  const stride = colliderStride(field)
-  const cols = sampleLine(field.cols, stride)
-  const rows = sampleLine(field.rows, stride)
-  const sink = new TriangleSink(field)
-
-  const xAt = (col: number) => field.origin[0] + col * field.spacing
-  const zAt = (row: number) => field.origin[1] + row * field.spacing
-  const at = (col: number, row: number): Vertex => ({
-    x: xAt(col),
-    y: heightAtSample(field, col, row),
-    z: zAt(row),
-  })
-
-  for (let ri = 0; ri < rows.length - 1; ri++) {
-    const r0 = rows[ri] as number
-    const r1 = rows[ri + 1] as number
-    for (let ci = 0; ci < cols.length - 1; ci++) {
-      const c0 = cols[ci] as number
-      const c1 = cols[ci + 1] as number
-      sink.quad(at(c0, r0), at(c1, r0), at(c0, r1), at(c1, r1))
-    }
-  }
-
-  // The skirt: each border sample extruded outward at its own height, so stepping
-  // off the field lands on the border height rather than on nothing. This is the
-  // collider spelling of `heightAt`'s edge clamp.
-  const firstCol = 0
-  const lastCol = field.cols - 1
-  const firstRow = 0
-  const lastRow = field.rows - 1
-  const westX = xAt(firstCol) - SKIRT_REACH
-  const eastX = xAt(lastCol) + SKIRT_REACH
-  const northZ = zAt(firstRow) - SKIRT_REACH
-  const southZ = zAt(lastRow) + SKIRT_REACH
-
-  for (let ci = 0; ci < cols.length - 1; ci++) {
-    const c0 = cols[ci] as number
-    const c1 = cols[ci + 1] as number
-    const north0 = at(c0, firstRow)
-    const north1 = at(c1, firstRow)
-    sink.quad(
-      { x: north0.x, y: north0.y, z: northZ },
-      { x: north1.x, y: north1.y, z: northZ },
-      north0,
-      north1,
-    )
-    const south0 = at(c0, lastRow)
-    const south1 = at(c1, lastRow)
-    sink.quad(
-      south0,
-      south1,
-      { x: south0.x, y: south0.y, z: southZ },
-      {
-        x: south1.x,
-        y: south1.y,
-        z: southZ,
-      },
-    )
-  }
-
-  for (let ri = 0; ri < rows.length - 1; ri++) {
-    const r0 = rows[ri] as number
-    const r1 = rows[ri + 1] as number
-    const west0 = at(firstCol, r0)
-    const west1 = at(firstCol, r1)
-    sink.quad(
-      { x: westX, y: west0.y, z: west0.z },
-      west0,
-      { x: westX, y: west1.y, z: west1.z },
-      west1,
-    )
-    const east0 = at(lastCol, r0)
-    const east1 = at(lastCol, r1)
-    sink.quad(east0, { x: eastX, y: east0.y, z: east0.z }, east1, {
-      x: eastX,
-      y: east1.y,
-      z: east1.z,
-    })
-  }
-
-  // Corner quads, flat at the corner sample's height — the diagonal region no edge
-  // strip covers, and where `heightAt` also reports the corner value.
-  const corners: Array<[Vertex, number, number]> = [
-    [at(firstCol, firstRow), westX, northZ],
-    [at(lastCol, firstRow), eastX, northZ],
-    [at(firstCol, lastRow), westX, southZ],
-    [at(lastCol, lastRow), eastX, southZ],
-  ]
-  for (const [corner, farX, farZ] of corners) {
-    const minX = Math.min(corner.x, farX)
-    const maxX = Math.max(corner.x, farX)
-    const minZ = Math.min(corner.z, farZ)
-    const maxZ = Math.max(corner.z, farZ)
-    const y = corner.y
-    sink.quad(
-      { x: minX, y, z: minZ },
-      { x: maxX, y, z: minZ },
-      { x: minX, y, z: maxZ },
-      { x: maxX, y, z: maxZ },
-    )
-  }
-
-  return sink.build()
-}

package/src/components/editor/floorplan-camera-sync.test.ts

@@ -1,249 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { CameraPose } from '@pascal-app/core'
-import { publishInitialCameraPose } from '../../lib/camera-pose'
-import type { NavigationSyncPose } from '../../store/use-editor'
-import {
-  cameraPoseToFloorplanNavigationPose,
-  createFloorplanCameraNavigationChannel,
-  createFloorplanCameraSyncBridge,
-  floorplanNavigationPoseToCameraPose,
-} from './floorplan-camera-sync'
-
-const cameraPose: CameraPose = {
-  fov: 50,
-  position: [3, 4, 4],
-  projection: 'perspective',
-  target: [0, 1, 0],
-  viewWidth: 12,
-}
-
-function cameraPoseAtAzimuth(
-  azimuth: number,
-  target: [number, number, number] = [0, 1, 0],
-): CameraPose {
-  const horizontalDistance = 5
-  return {
-    ...cameraPose,
-    position: [
-      target[0] + Math.sin(azimuth) * horizontalDistance,
-      4,
-      target[2] + Math.cos(azimuth) * horizontalDistance,
-    ],
-    target,
-  }
-}
-
-describe('floorplan camera sync', () => {
-  test('derives the floor-plan navigation pose from the generic camera pose', () => {
-    expect(
-      cameraPoseToFloorplanNavigationPose({
-        position: [10, 5, 0],
-        projection: 'perspective',
-        target: [0, 0, 0],
-        viewWidth: 20,
-      }),
-    ).toEqual({
-      source: '3d',
-      target: [0, 0, 0],
-      azimuth: Math.PI / 2,
-      viewWidth: 20,
-    })
-  })
-
-  test('applies a floor-plan pose while preserving the generic camera elevation and projection', () => {
-    expect(
-      floorplanNavigationPoseToCameraPose(
-        {
-          source: '2d',
-          revision: 4,
-          target: [10, 2, 20],
-          azimuth: Math.PI / 2,
-          viewWidth: 8,
-        },
-        cameraPose,
-      ),
-    ).toEqual({
-      fov: 50,
-      position: [15, 5, 20],
-      projection: 'perspective',
-      target: [10, 2, 20],
-      viewWidth: 8,
-    })
-  })
-
-  test('owns two-way synchronization without echoing tiny camera changes', () => {
-    const published: Array<Omit<NavigationSyncPose, 'revision'>> = []
-    const applied: CameraPose[] = []
-    const bridge = createFloorplanCameraSyncBridge({
-      applyCameraPose: (pose) => applied.push(pose),
-      publishNavigationPose: (pose) => published.push(pose),
-    })
-
-    bridge.receiveCameraPose(cameraPose)
-    bridge.receiveCameraPose({
-      ...cameraPose,
-      position: [3.0001, 4, 4],
-    })
-    bridge.receiveNavigationPose({
-      source: '2d',
-      revision: 1,
-      target: [10, 2, 20],
-      azimuth: Math.PI / 2,
-      viewWidth: 8,
-    })
-
-    expect(published).toHaveLength(1)
-    expect(published[0]?.source).toBe('3d')
-    expect(applied).toHaveLength(1)
-    expect(applied[0]).toMatchObject({
-      fov: 50,
-      projection: 'perspective',
-      target: [10, 2, 20],
-      viewWidth: 8,
-    })
-    expect(applied[0]?.position[0]).toBeCloseTo(15)
-    expect(applied[0]?.position[1]).toBeCloseTo(5)
-    expect(applied[0]?.position[2]).toBeCloseTo(20)
-  })
-
-  test('publishes sub-degree camera rotation for a real-time compass', () => {
-    const published: Array<Omit<NavigationSyncPose, 'revision'>> = []
-    const bridge = createFloorplanCameraSyncBridge({
-      applyCameraPose: () => {},
-      publishNavigationPose: (pose) => published.push(pose),
-    })
-
-    bridge.receiveCameraPose(cameraPoseAtAzimuth(0))
-    bridge.receiveCameraPose(cameraPoseAtAzimuth((0.9 * Math.PI) / 180))
-    expect(published).toHaveLength(2)
-    expect(published[1]?.azimuth).toBeCloseTo((0.9 * Math.PI) / 180)
-  })
-
-  test('keeps a sub-degree camera rotation when it arrives with a pan', () => {
-    const published: Array<Omit<NavigationSyncPose, 'revision'>> = []
-    const bridge = createFloorplanCameraSyncBridge({
-      applyCameraPose: () => {},
-      publishNavigationPose: (pose) => published.push(pose),
-    })
-
-    bridge.receiveCameraPose(cameraPoseAtAzimuth(0))
-    bridge.receiveCameraPose(cameraPoseAtAzimuth((0.5 * Math.PI) / 180, [1, 1, 0]))
-
-    expect(published).toHaveLength(2)
-    expect(published[1]).toMatchObject({
-      target: [1, 1, 0],
-    })
-    expect(published[1]?.azimuth).toBeCloseTo((0.5 * Math.PI) / 180)
-  })
-
-  test('keeps streaming live camera headings in 3D-only mode', () => {
-    const published: Array<Omit<NavigationSyncPose, 'revision'>> = []
-    const applied: CameraPose[] = []
-    const bridge = createFloorplanCameraSyncBridge({
-      active: false,
-      applyCameraPose: (pose) => applied.push(pose),
-      publishNavigationPose: (pose) => published.push(pose),
-    })
-    const latestPose = cameraPoseAtAzimuth(Math.PI / 2, [8, 1, 4])
-
-    bridge.receiveCameraPose(cameraPoseAtAzimuth(0))
-    bridge.receiveCameraPose(latestPose)
-    bridge.receiveNavigationPose({
-      source: '2d',
-      revision: 1,
-      target: [10, 2, 20],
-      azimuth: Math.PI / 2,
-      viewWidth: 8,
-    })
-
-    expect(published).toEqual([
-      {
-        source: '3d',
-        target: cameraPose.target,
-        azimuth: 0,
-        viewWidth: 12,
-      },
-      {
-        source: '3d',
-        target: latestPose.target,
-        azimuth: Math.PI / 2,
-        viewWidth: 12,
-      },
-    ])
-    expect(applied).toEqual([])
-
-    bridge.setActive(true)
-    expect(published).toHaveLength(2)
-    expect(applied).toEqual([])
-  })
-
-  test('applies the north-alignment pose used by the compass in 3D view', () => {
-    const applied: CameraPose[] = []
-    const bridge = createFloorplanCameraSyncBridge({
-      applyCameraPose: (pose) => applied.push(pose),
-      publishNavigationPose: () => {},
-    })
-    const currentPose = cameraPoseAtAzimuth(Math.PI / 2, [8, 1, 4])
-
-    bridge.receiveCameraPose(currentPose)
-    bridge.receiveNavigationPose({
-      source: '2d',
-      revision: 1,
-      target: [...currentPose.target],
-      azimuth: 0,
-      viewWidth: currentPose.viewWidth!,
-    })
-
-    expect(applied).toHaveLength(1)
-    expect(applied[0]).toMatchObject({
-      target: currentPose.target,
-      projection: currentPose.projection,
-      viewWidth: currentPose.viewWidth,
-    })
-    expect(applied[0]?.position[0]).toBeCloseTo(currentPose.target[0])
-    expect(applied[0]?.position[1]).toBeCloseTo(currentPose.position[1])
-    expect(applied[0]?.position[2]).toBeCloseTo(currentPose.target[2] + 5)
-  })
-
-  test('applies 2D-first navigation on initial load without a 3D interaction', () => {
-    const applied: CameraPose[] = []
-    const bridge = createFloorplanCameraSyncBridge({
-      applyCameraPose: (pose) => applied.push(pose),
-      publishNavigationPose: () => {},
-    })
-
-    bridge.receiveNavigationPose({
-      source: '2d',
-      revision: 1,
-      target: [10, 2, 20],
-      azimuth: Math.PI / 2,
-      viewWidth: 8,
-    })
-    expect(applied).toEqual([])
-
-    publishInitialCameraPose(() => bridge.receiveCameraPose(cameraPose))
-    expect(applied).toHaveLength(1)
-  })
-
-  test('delivers the live camera stream through transient subscribers', () => {
-    const channel = createFloorplanCameraNavigationChannel()
-    const received: NavigationSyncPose[] = []
-    const unsubscribe = channel.subscribe((pose) => received.push(pose))
-    const input = {
-      source: '3d' as const,
-      target: [0, 1, 2] as [number, number, number],
-      azimuth: 0.5,
-      viewWidth: 12,
-    }
-
-    channel.publish(input)
-    channel.publish({ ...input, azimuth: 0.75 })
-    unsubscribe()
-    channel.publish({ ...input, azimuth: 1 })
-
-    expect(received).toEqual([
-      { ...input, revision: 1 },
-      { ...input, azimuth: 0.75, revision: 2 },
-    ])
-  })
-})

package/src/components/editor/floorplan-camera-sync.ts

@@ -1,213 +0,0 @@
-'use client'
-
-import { type CameraPose, emitter } from '@pascal-app/core'
-import { useEffect, useRef } from 'react'
-import { subscribeCameraPose } from '../../store/camera-pose-store'
-import { subscribeNavigationSyncPose } from '../../store/navigation-sync-pose-store'
-import type { NavigationSyncPose, NavigationSyncPoseInput } from '../../store/use-editor'
-
-const POSITION_EPSILON = 0.001
-const AZIMUTH_EPSILON = 1e-4
-const VIEW_WIDTH_EPSILON = 0.001
-
-type FloorplanNavigationSnapshot = Omit<NavigationSyncPoseInput, 'source'>
-
-function angleDeltaRadians(a: number, b: number) {
-  return Math.atan2(Math.sin(a - b), Math.cos(a - b))
-}
-
-function normalizeNearZero(value: number) {
-  return Math.abs(value) < Number.EPSILON * 10 ? 0 : value
-}
-
-function navigationSnapshot(pose: NavigationSyncPoseInput): FloorplanNavigationSnapshot {
-  return {
-    target: [...pose.target],
-    azimuth: pose.azimuth,
-    viewWidth: pose.viewWidth,
-  }
-}
-
-function navigationSnapshotsEqual(
-  previous: FloorplanNavigationSnapshot,
-  next: FloorplanNavigationSnapshot,
-) {
-  return (
-    Math.abs(previous.target[0] - next.target[0]) < POSITION_EPSILON &&
-    Math.abs(previous.target[1] - next.target[1]) < POSITION_EPSILON &&
-    Math.abs(previous.target[2] - next.target[2]) < POSITION_EPSILON &&
-    Math.abs(angleDeltaRadians(previous.azimuth, next.azimuth)) < AZIMUTH_EPSILON &&
-    Math.abs(previous.viewWidth - next.viewWidth) < VIEW_WIDTH_EPSILON
-  )
-}
-
-export function cameraPoseToFloorplanNavigationPose(
-  pose: CameraPose,
-): NavigationSyncPoseInput | null {
-  if (!(pose.viewWidth !== undefined && Number.isFinite(pose.viewWidth) && pose.viewWidth > 0)) {
-    return null
-  }
-
-  return {
-    source: '3d',
-    target: [...pose.target],
-    azimuth: Math.atan2(pose.position[0] - pose.target[0], pose.position[2] - pose.target[2]),
-    viewWidth: pose.viewWidth,
-  }
-}
-
-export function floorplanNavigationPoseToCameraPose(
-  navigationPose: NavigationSyncPose,
-  cameraPose: CameraPose,
-): CameraPose {
-  const offsetX = cameraPose.position[0] - cameraPose.target[0]
-  const offsetY = cameraPose.position[1] - cameraPose.target[1]
-  const offsetZ = cameraPose.position[2] - cameraPose.target[2]
-  const horizontalDistance = Math.hypot(offsetX, offsetZ)
-  const horizontalX = normalizeNearZero(Math.sin(navigationPose.azimuth) * horizontalDistance)
-  const horizontalZ = normalizeNearZero(Math.cos(navigationPose.azimuth) * horizontalDistance)
-  const target: [number, number, number] = [...navigationPose.target]
-
-  return {
-    ...(cameraPose.fov === undefined ? {} : { fov: cameraPose.fov }),
-    position: [target[0] + horizontalX, target[1] + offsetY, target[2] + horizontalZ],
-    projection: cameraPose.projection,
-    target,
-    viewWidth: navigationPose.viewWidth,
-  }
-}
-
-export type FloorplanCameraSyncBridge = {
-  receiveCameraPose: (pose: CameraPose) => void
-  receiveNavigationPose: (pose: NavigationSyncPose | null) => void
-  setActive: (active: boolean) => void
-}
-
-export type FloorplanCameraNavigationChannel = {
-  publish: (pose: NavigationSyncPoseInput) => void
-  subscribe: (listener: (pose: NavigationSyncPose) => void) => () => void
-}
-
-export function createFloorplanCameraNavigationChannel(): FloorplanCameraNavigationChannel {
-  const listeners = new Set<(pose: NavigationSyncPose) => void>()
-  let revision = 0
-
-  return {
-    publish: (pose) => {
-      revision += 1
-      const revisedPose = { ...pose, revision }
-      for (const listener of listeners) {
-        listener(revisedPose)
-      }
-    },
-    subscribe: (listener) => {
-      listeners.add(listener)
-      return () => listeners.delete(listener)
-    },
-  }
-}
-
-const liveCameraNavigation = createFloorplanCameraNavigationChannel()
-
-export function subscribeFloorplanCameraNavigation(listener: (pose: NavigationSyncPose) => void) {
-  return liveCameraNavigation.subscribe(listener)
-}
-
-export function createFloorplanCameraSyncBridge({
-  active: initialActive = true,
-  applyCameraPose,
-  publishNavigationPose,
-}: {
-  active?: boolean
-  applyCameraPose: (pose: CameraPose) => void
-  publishNavigationPose: (pose: NavigationSyncPoseInput) => void
-}): FloorplanCameraSyncBridge {
-  let active = initialActive
-  let latestCameraPose: CameraPose | null = null
-  let pendingNavigationPose: NavigationSyncPose | null = null
-  let lastAppliedNavigationRevision = 0
-  let lastPublishedNavigation: FloorplanNavigationSnapshot | null = null
-
-  const applyPendingNavigationPose = () => {
-    if (!(latestCameraPose && pendingNavigationPose)) return false
-    if (pendingNavigationPose.revision === lastAppliedNavigationRevision) {
-      pendingNavigationPose = null
-      return false
-    }
-
-    const appliedPose = floorplanNavigationPoseToCameraPose(pendingNavigationPose, latestCameraPose)
-    const appliedNavigationPose = cameraPoseToFloorplanNavigationPose(appliedPose)
-    latestCameraPose = appliedPose
-    lastAppliedNavigationRevision = pendingNavigationPose.revision
-    pendingNavigationPose = null
-    if (appliedNavigationPose) {
-      lastPublishedNavigation = navigationSnapshot(appliedNavigationPose)
-    }
-    applyCameraPose(appliedPose)
-    return true
-  }
-
-  const publishCameraNavigationPose = (pose: CameraPose) => {
-    const navigationPose = cameraPoseToFloorplanNavigationPose(pose)
-    if (!navigationPose) return
-    const nextSnapshot = navigationSnapshot(navigationPose)
-    if (
-      lastPublishedNavigation &&
-      navigationSnapshotsEqual(lastPublishedNavigation, nextSnapshot)
-    ) {
-      return
-    }
-
-    lastPublishedNavigation = nextSnapshot
-    publishNavigationPose(navigationPose)
-  }
-
-  return {
-    receiveCameraPose: (pose) => {
-      latestCameraPose = pose
-      if (active && applyPendingNavigationPose()) return
-
-      publishCameraNavigationPose(pose)
-    },
-    receiveNavigationPose: (pose) => {
-      if (
-        !active ||
-        pose?.source !== '2d' ||
-        pose.revision === lastAppliedNavigationRevision ||
-        pose.revision === pendingNavigationPose?.revision
-      ) {
-        return
-      }
-
-      pendingNavigationPose = pose
-      applyPendingNavigationPose()
-    },
-    setActive: (nextActive) => {
-      if (active === nextActive) return
-      active = nextActive
-      if (!active) {
-        pendingNavigationPose = null
-        return
-      }
-      if (latestCameraPose) publishCameraNavigationPose(latestCameraPose)
-    },
-  }
-}
-
-export function useFloorplanCameraSyncBridge() {
-  // The compass is portalled into the always-visible viewer area, so its
-  // orientation-only 2D pose must still reach the camera while the floorplan
-  // itself is hidden in 3D view.
-  const bridgeRef = useRef<FloorplanCameraSyncBridge | null>(null)
-  if (!bridgeRef.current) {
-    bridgeRef.current = createFloorplanCameraSyncBridge({
-      applyCameraPose: (pose) => emitter.emit('camera-controls:apply-pose', pose),
-      publishNavigationPose: (pose) => liveCameraNavigation.publish(pose),
-    })
-  }
-  const bridge = bridgeRef.current
-
-  useEffect(() => subscribeCameraPose(bridge.receiveCameraPose), [bridge])
-
-  useEffect(() => subscribeNavigationSyncPose(bridge.receiveNavigationPose), [bridge])
-}

package/src/components/editor/localized-html.tsx

@@ -1,22 +0,0 @@
-'use client'
-
-import { PascalI18nProvider, usePascalI18n } from '@pascal-app/core'
-import { Html as DreiHtml } from '@react-three/drei'
-import { type ComponentProps, forwardRef } from 'react'
-
-/**
- * drei's `Html`, keeping the editor's i18n scope. `Html` renders its children
- * in a separate React root, which sees none of the surrounding context, so a
- * component inside it would translate with the default (English) scope instead
- * of the editor's `?lang=` or `<Editor locale>` one.
- */
-export const Html = forwardRef<HTMLDivElement, Omit<ComponentProps<typeof DreiHtml>, 'ref'>>(
-  function Html({ children, ...props }, ref) {
-    const i18n = usePascalI18n()
-    return (
-      <DreiHtml {...props} ref={ref}>
-        <PascalI18nProvider i18n={i18n}>{children}</PascalI18nProvider>
-      </DreiHtml>
-    )
-  },
-)