@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/units.ts

@@ -4,7 +4,8 @@ import {
   type BuildingNode,
   type LevelNode,
   pointInPolygon2D,
-  resolveAutoZonePolygon,
+  runAsSingleSceneHistoryStep,
+  sceneRegistry,
   snapWorldXZToBuildingLocal,
   UnitNode,
   useScene,
@@ -12,14 +13,13 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
-import useEditor, { type StructureLayer } from '../store/use-editor'
+import useEditor from '../store/use-editor'
 import { getActiveBuildingPose } from './world-grid-snap'
 
 type Nodes = Readonly<Record<AnyNodeId, AnyNode>>
 
 // Unit focus is a session gesture: the layer the user was on when focus began
 // comes back when focus ends, unless they switched layers by hand meanwhile.
-let restoreLayer: StructureLayer | null = null
 let entering = false
 let leaving = false
 
@@ -49,11 +49,7 @@ export function enterUnitFocus(unitId: UnitNode['id']): void {
     const unit = nodes[unitId]
     if (unit?.type !== 'unit') return
     const editor = useEditor.getState()
-    if (restoreLayer === null) restoreLayer = editor.structureLayer
-    if (editor.phase !== 'structure') editor.setPhase('structure')
-    if (useEditor.getState().structureLayer !== 'zones') {
-      useEditor.getState().setStructureLayer('zones')
-    }
+    if (editor.phase === 'site') editor.setPhase('building')
     const viewer = useViewer.getState()
     if (viewer.focusedUnitId !== unitId) viewer.setFocusedUnit(unitId)
 
@@ -72,19 +68,7 @@ export function enterUnitFocus(unitId: UnitNode['id']): void {
   }
 }
 
-function finishLeave(unitId: UnitNode['id'], keepLayer: boolean) {
-  const layer = restoreLayer
-  restoreLayer = null
-  const editor = useEditor.getState()
-  if (
-    !keepLayer &&
-    layer &&
-    layer !== 'zones' &&
-    editor.phase === 'structure' &&
-    editor.structureLayer === 'zones'
-  ) {
-    editor.setStructureLayer(layer)
-  }
+function finishLeave(unitId: UnitNode['id']) {
   const { selection, setSelection } = useViewer.getState()
   if (selection.selectedIds.length === 1 && selection.selectedIds[0] === unitId) {
     setSelection({ selectedIds: [] })
@@ -92,7 +76,7 @@ function finishLeave(unitId: UnitNode['id'], keepLayer: boolean) {
 }
 
 /** Ends unit focus. Returns false when no unit was focused. */
-export function leaveUnitFocus(options?: { keepLayer?: boolean }): boolean {
+export function leaveUnitFocus(): boolean {
   const viewer = useViewer.getState()
   const unitId = viewer.focusedUnitId
   if (!unitId) return false
@@ -102,7 +86,7 @@ export function leaveUnitFocus(options?: { keepLayer?: boolean }): boolean {
   } finally {
     leaving = false
   }
-  finishLeave(unitId, options?.keepLayer ?? false)
+  finishLeave(unitId)
   return true
 }
 
@@ -124,28 +108,75 @@ export function assignZoneToUnit(zoneId: ZoneNode['id'], unitId: UnitNode['id']
   if (updates.length > 0) updateNodes(updates)
 }
 
+/** The units of the building a zone's level belongs to, and the one listing the zone. */
+export function zoneUnits(
+  nodes: Nodes,
+  zoneId: string,
+): { buildingId: BuildingNode['id'] | null; units: UnitNode[]; current: UnitNode | null } {
+  const zone = nodes[zoneId as AnyNodeId]
+  const level = zone?.parentId ? nodes[zone.parentId as AnyNodeId] : undefined
+  const building = level?.parentId ? nodes[level.parentId as AnyNodeId] : undefined
+  if (building?.type !== 'building') return { buildingId: null, units: [], current: null }
+  const units = building.children.flatMap((id) => {
+    const child = nodes[id as AnyNodeId]
+    return child?.type === 'unit' ? [child] : []
+  })
+  return {
+    buildingId: building.id,
+    units,
+    current: units.find((unit) => unit.members.includes(zoneId as ZoneNode['id'])) ?? null,
+  }
+}
+
+/** Puts a zone in a new unit of its building (named "Unit N"), in one undo step, without focusing it. */
+export function addZoneToNewUnit(zoneId: ZoneNode['id']): UnitNode['id'] | null {
+  const { buildingId, units } = zoneUnits(useScene.getState().nodes, zoneId)
+  if (!buildingId) return null
+  const unit = UnitNode.parse({ name: `Unit ${units.length + 1}` })
+  runAsSingleSceneHistoryStep(useScene, () => {
+    useScene.getState().createNode(unit, buildingId)
+    assignZoneToUnit(zoneId, unit.id)
+  })
+  return unit.id
+}
+
 export function toggleZoneMembership(unitId: UnitNode['id'], zoneId: ZoneNode['id']): void {
   const unit = useScene.getState().nodes[unitId]
   if (unit?.type !== 'unit') return
   assignZoneToUnit(zoneId, unit.members.includes(zoneId) ? null : unitId)
 }
 
+/** How far (m) below a mezzanine's walking surface a hit still counts as on it (its plate and underside). */
+const MEZZANINE_HIT_TOLERANCE = 0.05
+
 /**
  * The zone under a point on the current level, in building-local XZ. A 3D
  * click lands on whatever surface is closest (a floor slab sits above the
  * zone fill), so painting resolves the zone from the hit point instead of the
- * hit mesh. Nested zones resolve to the smallest one.
+ * hit mesh. Nested zones resolve to the smallest one, except that a mezzanine
+ * the hit may be on always wins over its host. With the hit's height (`y`,
+ * level-local) a mezzanine counts only when the hit is on or above its plate —
+ * the host floor under it is the host's; without one (the plan, seen from
+ * above) the mezzanine on top wins.
  */
-export function zoneAtLevelPoint(x: number, z: number): ZoneNode | null {
+export function zoneAtLevelPoint(x: number, z: number, y?: number): ZoneNode | null {
   const levelId = useViewer.getState().selection.levelId
   if (!levelId) return null
   const nodes = useScene.getState().nodes
-  const resolve = (id: AnyNodeId) => nodes[id]
   let best: ZoneNode | null = null
   let bestArea = Number.POSITIVE_INFINITY
+  let bestOnTop = false
   for (const node of Object.values(nodes)) {
     if (node.type !== 'zone' || node.parentId !== levelId) continue
-    const polygon = resolveAutoZonePolygon(node, resolve)
+    // An eligible mezzanine is the surface on top: it beats its host whatever
+    // their areas (a mezzanine may cover its whole host).
+    const onTop = node.floor?.support === 'open'
+    if (y !== undefined && onTop) {
+      const underside = (node.floor!.elevation ?? 0) - (node.floor!.thickness ?? 0.2)
+      if (y < underside - MEZZANINE_HIT_TOLERANCE) continue
+    }
+    if (bestOnTop && !onTop) continue
+    const polygon = node.polygon
     if (!pointInPolygon2D([x, z], polygon)) continue
     let area = 0
     for (let i = 0; i < polygon.length; i++) {
@@ -154,20 +185,30 @@ export function zoneAtLevelPoint(x: number, z: number): ZoneNode | null {
       area += a[0] * b[1] - b[0] * a[1]
     }
     area = Math.abs(area) / 2
-    if (area < bestArea) {
+    if (area < bestArea || (onTop && !bestOnTop)) {
       best = node
       bestArea = area
+      bestOnTop = onTop
     }
   }
   return best
 }
 
-export function zoneAtWorldPoint(worldX: number, worldZ: number): ZoneNode | null {
+/** `worldY` (optional): the hit's height, so a click under a mezzanine picks the host. */
+export function zoneAtWorldPoint(worldX: number, worldZ: number, worldY?: number): ZoneNode | null {
   const pose = getActiveBuildingPose()
   const [x, z] = pose
     ? snapWorldXZToBuildingLocal(worldX, worldZ, pose.position, pose.rotationY, 0).local
     : [worldX, worldZ]
-  return zoneAtLevelPoint(x, z)
+  return zoneAtLevelPoint(x, z, worldY === undefined ? undefined : levelLocalY(worldY))
+}
+
+function levelLocalY(worldY: number): number {
+  const levelId = useViewer.getState().selection.levelId
+  const level = levelId ? sceneRegistry.nodes.get(levelId) : undefined
+  if (!level) return worldY
+  level.updateWorldMatrix(true, false)
+  return worldY - level.matrixWorld.elements[13]!
 }
 
 export const ZONE_PAINT_DELAY_MS = 250
@@ -211,32 +252,29 @@ export function createUnitInBuilding(buildingId: BuildingNode['id']): UnitNode['
 /**
  * Keeps unit focus coherent with the rest of the editor: a focus set from
  * anywhere (the unit inspector calls the viewer store directly) gets the full
- * enter treatment, and focus ends when the user switches layer or phase by
- * hand, selects anything other than the focused unit, or the unit is deleted.
+ * enter treatment, and focus ends when the user goes to site, selects
+ * anything other than the focused unit, or the unit is deleted.
  */
 export function useUnitFocusRules(): void {
   useEffect(() => {
     const unsubscribeViewer = useViewer.subscribe((state, prev) => {
       if (state.focusedUnitId !== prev.focusedUnitId) {
         if (state.focusedUnitId) enterUnitFocus(state.focusedUnitId)
-        else if (prev.focusedUnitId && !leaving) finishLeave(prev.focusedUnitId, false)
+        else if (prev.focusedUnitId && !leaving) finishLeave(prev.focusedUnitId)
         return
       }
       const unitId = state.focusedUnitId
       if (!unitId || state.selection === prev.selection) return
       // Selecting a zone keeps focus: renaming or recolouring a zone row is
-      // part of arranging the unit, and zones live on the layer focus uses.
+      // part of arranging the unit.
       const { selectedIds } = state.selection
       const selectsOther =
         selectedIds.length > 0 && !(selectedIds.length === 1 && selectedIds[0] === unitId)
       if (selectsOther) leaveUnitFocus()
     })
     const unsubscribeEditor = useEditor.subscribe((state, prev) => {
-      if (state.structureLayer === prev.structureLayer && state.phase === prev.phase) return
-      if (!useViewer.getState().focusedUnitId) return
-      if (state.phase !== 'structure' || state.structureLayer !== 'zones') {
-        leaveUnitFocus({ keepLayer: true })
-      }
+      if (state.phase === prev.phase || state.phase === 'building') return
+      if (useViewer.getState().focusedUnitId) leaveUnitFocus()
     })
     const unsubscribeScene = useScene.subscribe((state, prev) => {
       if (state.nodes === prev.nodes) return

package/src/lib/vector-edges.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+import * as THREE from 'three'
+import { candidateEdges, hideUndrawnMeshes, materialShows } from './vector-edges'
+
+/** A unit box's feature edges: 12, six floats each. */
+const BOX_EDGE_FLOATS = 12 * 6
+
+function sceneWithProxy() {
+  const scene = new THREE.Scene()
+  const house = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshBasicMaterial())
+  // a utility-pole pick proxy: a tall box that draws nothing
+  const proxy = new THREE.Mesh(
+    new THREE.BoxGeometry(0.5, 10.7, 0.5),
+    new THREE.MeshBasicMaterial({ colorWrite: false, depthWrite: false }),
+  )
+  proxy.position.set(3, 0, 0)
+  scene.add(house, proxy)
+  scene.updateMatrixWorld(true)
+  return { scene, house, proxy }
+}
+
+describe('vector edges skip what draws nothing', () => {
+  test('a pick proxy (colorWrite false) has no lines', () => {
+    const { scene } = sceneWithProxy()
+    const camera = new THREE.OrthographicCamera(-10, 10, 10, -10, 0.1, 100)
+    const world = candidateEdges(scene, camera, 20, 400_000)
+    expect(world).toHaveLength(BOX_EDGE_FLOATS)
+    // every edge is the 1 m box's, none the 10.7 m proxy's
+    for (let i = 1; i < world.length; i += 3)
+      expect(Math.abs(world[i] as number)).toBeLessThanOrEqual(0.5)
+  })
+
+  test('hidden materials, see-through hit boxes and colour-masked colliders all count as undrawn', () => {
+    expect(materialShows(new THREE.MeshBasicMaterial())).toBe(true)
+    expect(materialShows(new THREE.MeshBasicMaterial({ colorWrite: false }))).toBe(false)
+    expect(materialShows(new THREE.MeshBasicMaterial({ visible: false }))).toBe(false)
+    expect(materialShows(new THREE.MeshBasicMaterial({ transparent: true, opacity: 0 }))).toBe(
+      false,
+    )
+    expect(
+      materialShows([
+        new THREE.MeshBasicMaterial({ colorWrite: false }),
+        new THREE.MeshBasicMaterial(),
+      ]),
+    ).toBe(true)
+  })
+
+  test('the depth and normal passes see no pick proxy, and it comes back after', () => {
+    const { scene, house, proxy } = sceneWithProxy()
+    const show = hideUndrawnMeshes(scene)
+    // under the passes' override material the proxy would write depth and
+    // hide the real edges behind it
+    expect(proxy.visible).toBe(false)
+    expect(house.visible).toBe(true)
+    show()
+    expect(proxy.visible).toBe(true)
+  })
+})

package/src/lib/vector-edges.ts

@@ -0,0 +1,400 @@
+/**
+ * VECTOR EDGES FROM THE VIEWER — the elevation's lines taken from the same
+ * meshes the picture is rendered from, with hidden-line removal.
+ *
+ * A drawing built from a second model of the house (a plugin's section solids)
+ * never quite matches the render: its roof sat on the plate plane while the
+ * 3D roof stacks a deck and shingles on it, its door was the opening while
+ * the render showed the leaf. This is how Revit and Chief Architect avoid
+ * that — ONE model, the view's lines derived from it:
+ *
+ *   1. every visible mesh's FEATURE EDGES (creases over `thresholdDeg`,
+ *      boundaries — three's EdgesGeometry, cached per geometry), carried
+ *      to world space, instance by instance for InstancedMeshes;
+ *   2. a DEPTH pass of the scene through the capture camera — view-space
+ *      depth as a float colour, read back once;
+ *   3. each edge projected through that camera and SAMPLED along its length
+ *      against the depth buffer: a point deeper than what the buffer saw is
+ *      behind something. The visible runs come back as world segments.
+ *
+ * Orthographic only (an elevation, a section): depth is linear across a face
+ * so the interpolated edge depth is exact. Not a boolean operation — an
+ * edge test, cheap enough to run at capture time.
+ */
+import * as THREE from 'three'
+import { normalView, positionView, vec4 } from 'three/tsl'
+import { MeshBasicNodeMaterial, RenderTarget } from 'three/webgpu'
+
+export type VisibleEdges = {
+  /** World-space segments, six floats each: ax ay az bx by bz. */
+  segments: Float32Array
+  count: number
+  /** How many candidate edges were tested, and the depth pass' size. */
+  tested: number
+  width: number
+  height: number
+  ms: number
+  /** Whether the normal pass came back (without it every in-view edge is kept). */
+  normals: boolean
+}
+
+const edgeCache = new WeakMap<THREE.BufferGeometry, Map<number, Float32Array | null>>()
+
+/** The feature edges of a geometry, local space, as pairs of points (cached per threshold; null when the geometry is too heavy). */
+function featureEdgesOf(
+  geometry: THREE.BufferGeometry,
+  thresholdDeg: number,
+  maxTriangles: number,
+): Float32Array | null {
+  const position = geometry.getAttribute('position')
+  if (!position) return null
+  const triangles = geometry.index ? geometry.index.count / 3 : position.count / 3
+  if (triangles > maxTriangles) return null
+  let byThreshold = edgeCache.get(geometry)
+  if (!byThreshold) {
+    byThreshold = new Map()
+    edgeCache.set(geometry, byThreshold)
+  }
+  const cached = byThreshold.get(thresholdDeg)
+  if (cached !== undefined) return cached
+  let edges: Float32Array | null = null
+  try {
+    const eg = new THREE.EdgesGeometry(geometry, thresholdDeg)
+    const attr = eg.getAttribute('position')
+    edges = attr ? new Float32Array(attr.array as ArrayLike<number>) : null
+    eg.dispose()
+  } catch {
+    edges = null
+  }
+  byThreshold.set(thresholdDeg, edges)
+  return edges
+}
+
+function isShown(object: THREE.Object3D): boolean {
+  let o: THREE.Object3D | null = object
+  while (o) {
+    if (!o.visible) return false
+    o = o.parent
+  }
+  return true
+}
+
+/**
+ * Whether a material draws anything. `colorWrite: false` is how a pick-only
+ * collider hides on the GPU (a plugin's utility-pole proxy, 0.5 × 10.7 m, once
+ * drew a tall rectangle through the elevations, 2026-09-23 — the rule
+ * glb-export's `isRenderableMesh` already follows).
+ */
+export function materialShows(material: THREE.Material | THREE.Material[]): boolean {
+  const list = Array.isArray(material) ? material : [material]
+  return list.some(
+    (m) =>
+      m && m.visible !== false && m.colorWrite !== false && !(m.transparent && m.opacity <= 0.02),
+  )
+}
+
+/**
+ * The shown meshes whose own materials draw nothing — pick proxies, hit
+ * boxes — hidden for the length of the buffer passes: under the passes'
+ * override material they would write depth and hide the real edges behind
+ * them. The returned function shows them again.
+ */
+export function hideUndrawnMeshes(scene: THREE.Object3D): () => void {
+  const hidden: THREE.Object3D[] = []
+  scene.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    if (!mesh.isMesh || !mesh.visible || materialShows(mesh.material)) return
+    mesh.visible = false
+    hidden.push(mesh)
+  })
+  return () => {
+    for (const mesh of hidden) mesh.visible = true
+  }
+}
+
+/**
+ * One pass of the scene through `material` into a float target, read back:
+ * the depth pass writes view-space depth (metres in front of the camera) in
+ * red; the normal pass the view-space normal in RGB.
+ */
+async function bufferPass(
+  renderer: THREE.WebGLRenderer,
+  scene: THREE.Scene,
+  camera: THREE.Camera,
+  width: number,
+  height: number,
+  colorNode: unknown,
+): Promise<{ data: Float32Array; topDown: boolean } | null> {
+  const material = new MeshBasicNodeMaterial()
+  material.colorNode = colorNode as never
+  material.side = THREE.DoubleSide
+  material.transparent = false
+  material.depthTest = true
+  material.depthWrite = true
+  const target = new RenderTarget(width, height, {
+    type: THREE.FloatType,
+    format: THREE.RGBAFormat,
+    depthBuffer: true,
+    minFilter: THREE.NearestFilter,
+    magFilter: THREE.NearestFilter,
+    generateMipmaps: false,
+  })
+  const gl = renderer as unknown as {
+    getRenderTarget: () => unknown
+    setRenderTarget: (t: unknown) => void
+    getClearColor: (c: THREE.Color) => THREE.Color
+    getClearAlpha: () => number
+    setClearColor: (c: THREE.Color | number, a?: number) => void
+    renderAsync: (s: THREE.Scene, c: THREE.Camera) => Promise<void>
+    readRenderTargetPixelsAsync: (
+      t: unknown,
+      x: number,
+      y: number,
+      w: number,
+      h: number,
+    ) => Promise<ArrayLike<number>>
+    backend?: { device?: unknown }
+  }
+  const previousTarget = gl.getRenderTarget()
+  const previousOverride = scene.overrideMaterial
+  const previousClear = gl.getClearColor(new THREE.Color())
+  const previousAlpha = gl.getClearAlpha()
+  try {
+    scene.overrideMaterial = material
+    gl.setClearColor(new THREE.Color(0, 0, 0), 0)
+    gl.setRenderTarget(target)
+    await gl.renderAsync(scene, camera)
+    gl.setRenderTarget(null)
+    const raw = await gl.readRenderTargetPixelsAsync(target, 0, 0, width, height)
+    const data = raw instanceof Float32Array ? raw : new Float32Array(raw)
+    if (data.length < width * height * 4) return null
+    // WebGPU reads rows top-down; the WebGL fallback bottom-up
+    return { data, topDown: Boolean(gl.backend?.device) }
+  } catch (error) {
+    console.warn('[vector-edges] buffer pass failed', error)
+    return null
+  } finally {
+    scene.overrideMaterial = previousOverride
+    gl.setClearColor(previousClear, previousAlpha)
+    gl.setRenderTarget(previousTarget)
+    target.dispose()
+    material.dispose()
+  }
+}
+
+/**
+ * Every drawn mesh's feature edges in world space, six floats per edge —
+ * instance by instance for an InstancedMesh. What draws nothing (a hidden
+ * mesh, a pick proxy, a layer the camera does not see) has no lines.
+ */
+export function candidateEdges(
+  scene: THREE.Object3D,
+  camera: THREE.Camera,
+  thresholdDeg: number,
+  maxTriangles: number,
+): number[] {
+  const world: number[] = []
+  const a = new THREE.Vector3()
+  const b = new THREE.Vector3()
+  const instance = new THREE.Matrix4()
+  const composed = new THREE.Matrix4()
+  scene.traverse((object) => {
+    const mesh = object as THREE.Mesh
+    if (!mesh.isMesh || !mesh.geometry) return
+    if ((mesh as unknown as { isSkinnedMesh?: boolean }).isSkinnedMesh) return
+    if (!camera.layers.test(mesh.layers)) return
+    if (!isShown(mesh) || !materialShows(mesh.material)) return
+    const edges = featureEdgesOf(mesh.geometry, thresholdDeg, maxTriangles)
+    if (!edges || edges.length < 6) return
+    const instanced = mesh as unknown as THREE.InstancedMesh
+    const matrices: THREE.Matrix4[] = []
+    if (instanced.isInstancedMesh) {
+      for (let i = 0; i < instanced.count; i++) {
+        instanced.getMatrixAt(i, instance)
+        matrices.push(composed.copy(mesh.matrixWorld).multiply(instance).clone())
+      }
+    } else {
+      matrices.push(mesh.matrixWorld)
+    }
+    for (const m of matrices) {
+      for (let i = 0; i + 5 < edges.length; i += 6) {
+        a.set(edges[i] as number, edges[i + 1] as number, edges[i + 2] as number).applyMatrix4(m)
+        b.set(edges[i + 3] as number, edges[i + 4] as number, edges[i + 5] as number).applyMatrix4(
+          m,
+        )
+        world.push(a.x, a.y, a.z, b.x, b.y, b.z)
+      }
+    }
+  })
+  return world
+}
+
+/**
+ * The visible feature edges of `scene` through `camera` (orthographic), as
+ * world segments. `width` sets the depth pass (a multiple of 16 keeps the
+ * WebGPU readback rows unpadded); `height` follows the camera's aspect.
+ */
+export async function extractVisibleEdges(
+  renderer: THREE.WebGLRenderer,
+  scene: THREE.Scene,
+  camera: THREE.OrthographicCamera,
+  options: { width?: number; thresholdDeg?: number; maxTriangles?: number; bias?: number } = {},
+): Promise<VisibleEdges | null> {
+  const started = performance.now()
+  const thresholdDeg = options.thresholdDeg ?? 20
+  const maxTriangles = options.maxTriangles ?? 400_000
+  const aspect = (camera.right - camera.left) / Math.max(1e-6, camera.top - camera.bottom)
+  const width = Math.max(16, Math.round((options.width ?? 2048) / 16) * 16)
+  const height = Math.max(16, Math.round(width / aspect / 16) * 16)
+  camera.updateMatrixWorld(true)
+  scene.updateMatrixWorld(true)
+
+  const showUndrawn = hideUndrawnMeshes(scene)
+  let pass: Awaited<ReturnType<typeof bufferPass>>
+  let normalPass: Awaited<ReturnType<typeof bufferPass>> = null
+  try {
+    pass = await bufferPass(
+      renderer,
+      scene,
+      camera,
+      width,
+      height,
+      vec4(positionView.z.negate(), 0, 0, 1),
+    )
+    if (pass)
+      normalPass = await bufferPass(renderer, scene, camera, width, height, vec4(normalView, 1))
+  } finally {
+    showUndrawn()
+  }
+  if (!pass) return null
+  const { data: depth, topDown } = pass
+  const normals = normalPass?.data ?? null
+
+  const world = candidateEdges(scene, camera, thresholdDeg, maxTriangles)
+
+  // ── the visibility test ──────────────────────────────────────────────
+  const view = camera.matrixWorldInverse
+  const proj = camera.projectionMatrix
+  const bias = options.bias ?? 0.008
+  const out: number[] = []
+  const va = new THREE.Vector3()
+  const vb = new THREE.Vector3()
+  const pa = new THREE.Vector3()
+  const pb = new THREE.Vector3()
+  const indexAt = (px: number, py: number): number => {
+    const x = Math.floor(px)
+    const y = Math.floor(py)
+    if (x < 0 || y < 0 || x >= width || y >= height) return -1
+    const row = topDown ? y : height - 1 - y
+    return (row * width + x) * 4
+  }
+  const sampleAt = (px: number, py: number): number => {
+    const k = indexAt(px, py)
+    return k < 0 ? Number.POSITIVE_INFINITY : (depth[k] as number)
+  }
+  // A line is only a line where the render CHANGES across it: a step in
+  // depth (a silhouette, a reveal, the far side of a box) or a crease in
+  // the normal (wall meets roof, the corner of a post). A flat face's own
+  // triangulation — the CSG walls come with T-junctions, so the edge
+  // finder cannot pair those triangles — shows neither and is dropped.
+  const CREASE = Math.cos((15 * Math.PI) / 180)
+  const ACROSS = 2
+  const featureAt = (px: number, py: number, nx: number, ny: number): boolean => {
+    const c = sampleAt(px, py)
+    const l = sampleAt(px + nx * ACROSS, py + ny * ACROSS)
+    const r = sampleAt(px - nx * ACROSS, py - ny * ACROSS)
+    // the sky on either side, or off the frame: a silhouette
+    if (c === 0 || l === 0 || r === 0) return true
+    if (!Number.isFinite(l) || !Number.isFinite(r) || !Number.isFinite(c)) return true
+    // a step, not a slope: the second difference is zero on any plane
+    if (Math.abs(l + r - 2 * c) > 0.012) return true
+    if (!normals) return true
+    const kl = indexAt(px + nx * ACROSS, py + ny * ACROSS)
+    const kr = indexAt(px - nx * ACROSS, py - ny * ACROSS)
+    if (kl < 0 || kr < 0) return true
+    // unsigned: a CSG face's triangles may wind either way, and a flipped
+    // normal on a flat wall is not a corner
+    const dot =
+      (normals[kl] as number) * (normals[kr] as number) +
+      (normals[kl + 1] as number) * (normals[kr + 1] as number) +
+      (normals[kl + 2] as number) * (normals[kr + 2] as number)
+    return Math.abs(dot) < CREASE
+  }
+  const tested = world.length / 6
+  for (let i = 0; i + 5 < world.length; i += 6) {
+    va.set(world[i] as number, world[i + 1] as number, world[i + 2] as number).applyMatrix4(view)
+    vb.set(world[i + 3] as number, world[i + 4] as number, world[i + 5] as number).applyMatrix4(
+      view,
+    )
+    const da = -va.z
+    const db = -vb.z
+    if (da <= camera.near && db <= camera.near) continue
+    pa.copy(va).applyMatrix4(proj)
+    pb.copy(vb).applyMatrix4(proj)
+    const ax = ((pa.x + 1) / 2) * width
+    const ay = ((1 - pa.y) / 2) * height
+    const bx = ((pb.x + 1) / 2) * width
+    const by = ((1 - pb.y) / 2) * height
+    // wholly off the frame: nothing to test
+    if (
+      (ax < 0 && bx < 0) ||
+      (ax >= width && bx >= width) ||
+      (ay < 0 && by < 0) ||
+      (ay >= height && by >= height)
+    ) {
+      continue
+    }
+    const lengthPx = Math.hypot(bx - ax, by - ay)
+    const n = Math.min(4096, Math.max(2, Math.ceil(lengthPx)))
+    const slope = Math.abs(db - da) / n
+    const tolerance = bias + slope * 1.5
+    // the screen-space perpendicular, to look across the edge
+    const nx = lengthPx > 1e-6 ? -(by - ay) / lengthPx : 1
+    const ny = lengthPx > 1e-6 ? (bx - ax) / lengthPx : 0
+    let runStart = -1
+    let gap = 0
+    const emit = (t0: number, t1: number) => {
+      if (t1 - t0 <= 0) return
+      out.push(
+        (world[i] as number) + ((world[i + 3] as number) - (world[i] as number)) * t0,
+        (world[i + 1] as number) + ((world[i + 4] as number) - (world[i + 1] as number)) * t0,
+        (world[i + 2] as number) + ((world[i + 5] as number) - (world[i + 2] as number)) * t0,
+        (world[i] as number) + ((world[i + 3] as number) - (world[i] as number)) * t1,
+        (world[i + 1] as number) + ((world[i + 4] as number) - (world[i + 1] as number)) * t1,
+        (world[i + 2] as number) + ((world[i + 5] as number) - (world[i + 2] as number)) * t1,
+      )
+    }
+    for (let s = 0; s <= n; s++) {
+      const t = s / n
+      const px = ax + (bx - ax) * t
+      const py = ay + (by - ay) * t
+      const d = da + (db - da) * t
+      const seen = sampleAt(px, py)
+      // the background (nothing drawn) reads 0; off the frame reads Infinity — both leave the edge in view
+      const inView = seen === 0 || seen === Number.POSITIVE_INFINITY || d <= seen + tolerance
+      const visible = inView && featureAt(px, py, nx, ny)
+      if (visible) {
+        if (runStart < 0) runStart = t
+        gap = 0
+      } else if (runStart >= 0) {
+        // a single hidden sample inside a run is rasterisation noise, not an occluder
+        gap++
+        if (gap > 1) {
+          emit(runStart, (s - gap) / n)
+          runStart = -1
+          gap = 0
+        }
+      }
+    }
+    if (runStart >= 0) emit(runStart, 1)
+  }
+  return {
+    segments: new Float32Array(out),
+    count: out.length / 6,
+    tested,
+    width,
+    height,
+    ms: Math.round(performance.now() - started),
+    normals: normals !== null,
+  }
+}