minecraft-renderer 0.1.88 → 0.1.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.88",
+  "version": "0.1.90",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/mesher-shared/faceOcclusion.ts

@@ -253,19 +253,21 @@ function getBlockFromStateId(version: string, stateId: number) {
   return Block.fromStateId(stateId, 1)
 }
 
-function getAllShapesForState(version: string, stateId: number, blockProvider: WorldBlockProvider): Uint16Array[] {
-  const cacheKey = `${version}:${stateId}`
-  const cached = shapeCache.get(cacheKey)
-  if (cached) return cached
-
-  const shapes = DIR_KEYS.map(() => emptyShape())
-  const blockObj = getBlockFromStateId(version, stateId)
-  if (!blockObj || !blockRendersSolid(blockObj)) {
-    shapeCache.set(cacheKey, shapes)
-    return shapes
+function isFullCubeRenderModel(models: BlockModelPartsResolved | undefined): boolean {
+  try {
+    if (!models?.length || models.length !== 1) return false
+    return models[0]!.every(v =>
+      (v.elements ?? []).every(e => {
+        return e.from[0] === 0 && e.from[1] === 0 && e.from[2] === 0 && e.to[0] === 16 && e.to[1] === 16 && e.to[2] === 16
+      })
+    )
+  } catch {
+    return false
   }
+}
 
-  const models = blockProvider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false) as BlockModelPartsResolved
+function buildShapesFromRenderModel(models: BlockModelPartsResolved | undefined): Uint16Array[] {
+  const shapes = DIR_KEYS.map(() => emptyShape())
 
   for (const modelVars of models ?? []) {
     const model = modelVars[0]
@@ -289,10 +291,52 @@ function getAllShapesForState(version: string, stateId: number, blockProvider: W
     }
   }
 
-  shapeCache.set(cacheKey, shapes)
   return shapes
 }
 
+function buildShapesFromCollisionBoxes(boxes: number[][]): Uint16Array[] {
+  const shapes = DIR_KEYS.map(() => emptyShape())
+
+  for (const box of boxes) {
+    const x0 = snapBlockUnit(box[0]! * 16)
+    const y0 = snapBlockUnit(box[1]! * 16)
+    const z0 = snapBlockUnit(box[2]! * 16)
+    const x1 = snapBlockUnit(box[3]! * 16)
+    const y1 = snapBlockUnit(box[4]! * 16)
+    const z1 = snapBlockUnit(box[5]! * 16)
+
+    if (y1 === 16) orRectIntoShape(x0, z0, x1, z1, shapes[dirIndex([0, 1, 0])]!)
+    if (y0 === 0) orRectIntoShape(x0, z0, x1, z1, shapes[dirIndex([0, -1, 0])]!)
+    if (x1 === 16) orRectIntoShape(z0, y0, z1, y1, shapes[dirIndex([1, 0, 0])]!)
+    if (x0 === 0) orRectIntoShape(z0, y0, z1, y1, shapes[dirIndex([-1, 0, 0])]!)
+    if (z1 === 16) orRectIntoShape(x0, y0, x1, y1, shapes[dirIndex([0, 0, 1])]!)
+    if (z0 === 0) orRectIntoShape(x0, y0, x1, y1, shapes[dirIndex([0, 0, -1])]!)
+  }
+
+  return shapes
+}
+
+function getAllShapesForState(version: string, stateId: number, blockProvider: WorldBlockProvider): Uint16Array[] {
+  const cacheKey = `${version}:${stateId}`
+  const cached = shapeCache.get(cacheKey)
+  if (cached) return cached
+
+  const shapes = DIR_KEYS.map(() => emptyShape())
+  const blockObj = getBlockFromStateId(version, stateId)
+  if (!blockObj || !blockRendersSolid(blockObj)) {
+    shapeCache.set(cacheKey, shapes)
+    return shapes
+  }
+
+  const models = blockProvider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false) as BlockModelPartsResolved
+  const boxes = blockObj.shapes as number[][] | undefined
+
+  const resolvedShapes = isFullCubeRenderModel(models) ? buildShapesFromRenderModel(models) : boxes?.length ? buildShapesFromCollisionBoxes(boxes) : shapes
+
+  shapeCache.set(cacheKey, resolvedShapes)
+  return resolvedShapes
+}
+
 export function getOcclusionShape(version: string, stateId: number, worldDir: CardinalDir, blockProvider: WorldBlockProvider): Uint16Array {
   return getAllShapesForState(version, stateId, blockProvider)[dirIndex(worldDir)]!
 }

package/src/mesher-shared/tests/faceOcclusion.test.ts

@@ -73,6 +73,42 @@ test('getOcclusionShape: full cube covers entire plane', () => {
   }
 })
 
+test('getOcclusionShape: cactus down occlusion is inset, not full footprint', () => {
+  const mcData = MinecraftData(VERSION)
+  const cactusId = mcData.blocksByName.cactus!.defaultState
+  const downShape = getOcclusionShape(VERSION, cactusId, [0, -1, 0], blockProvider())
+  expect(downShape[0]! & 1).toBe(0)
+  expect(downShape[0]! & (1 << 15)).toBe(0)
+  let covered = 0
+  for (let row = 0; row < 16; row++) {
+    for (let col = 0; col < 16; col++) {
+      if (downShape[row]! & (1 << col)) covered++
+    }
+  }
+  expect(covered).toBe(14 * 14)
+  expect(getOcclusionShape(VERSION, cactusId, [0, 1, 0], blockProvider())[0]).toBe(0)
+})
+
+test('faceIsCulled: grass top not culled by cactus above', () => {
+  const mcData = MinecraftData(VERSION)
+  const grassId = mcData.blocksByName.grass_block!.defaultState
+  const cactusId = mcData.blocksByName.cactus!.defaultState
+  const provider = blockProvider()
+  const blockObj = PrismarineBlockLoader(VERSION).fromStateId(grassId, 1)
+  const models = provider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false)
+  const element = models[0]![0]!.elements![0]!
+  expect(faceIsCulled(VERSION, element, 'up', cactusId, { stateId: grassId, name: 'grass_block' }, provider, [0, 1, 0], null)).toBe(false)
+})
+
+test('getOcclusionShape: soul sand keeps full render-model occlusion despite shorter collision', () => {
+  const mcData = MinecraftData(VERSION)
+  const soulSandId = mcData.blocksByName.soul_sand!.defaultState
+  const downShape = getOcclusionShape(VERSION, soulSandId, [0, -1, 0], blockProvider())
+  for (let row = 0; row < 16; row++) {
+    expect(downShape[row]).toBe(0xffff)
+  }
+})
+
 test('getOcclusionShape: farmland side is shorter than full height', () => {
   const mcData = MinecraftData(VERSION)
   const farmlandId = mcData.blocksByName.farmland!.defaultState

package/src/playground/scenes/partialBlockCulling.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import { BasePlaygroundScene } from '../baseScene'
 
-/** Manual check for issue #49: farmland field + cut copper stairs (1.18.2). */
+/** Manual check for issue #49/#73: partial-block culling + cactus on grass (1.18.2). */
 export default class extends BasePlaygroundScene {
   override version = '1.18.2'
   enableCameraOrbitControl = true
@@ -27,5 +27,18 @@ export default class extends BasePlaygroundScene {
       this.addWorldBlock(20 + x, stairY, 4, 'cut_copper_stairs', stairProps)
       this.addWorldBlock(20 + x, stairY + 1, 4, 'cut_copper_stairs', stairProps)
     }
+
+    const cactusY = 64
+    for (let x = 0; x < 4; x++) {
+      this.addWorldBlock(30 + x, cactusY - 1, 8, 'grass_block')
+      this.addWorldBlock(30 + x, cactusY, 8, 'cactus')
+    }
+    this.addWorldBlock(35, cactusY - 1, 8, 'grass_block')
+    this.addWorldBlock(35, cactusY, 8, 'cactus')
+    this.addWorldBlock(35, cactusY + 1, 8, 'cactus')
+
+    this.addWorldBlock(30, cactusY - 1, 10, 'soul_sand')
+    this.addWorldBlock(31, cactusY - 1, 10, 'stone_slab', { type: 'bottom' })
+    this.addWorldBlock(32, cactusY - 1, 10, 'stone_slab', { type: 'bottom' })
   }
 }

package/src/three/cubeDrawSpans.ts

@@ -1,11 +1,5 @@
 //@ts-nocheck
-import {
-  assertDrawSpansWithinLiveRanges,
-  carveSpansAroundPendingRanges,
-  FULL_DRAW_VISIBLE_FRACTION,
-  MAX_OPAQUE_SPANS,
-  type DirtyRange
-} from './globalLegacyBuffer'
+import { carveSpansAroundPendingRanges, FULL_DRAW_VISIBLE_FRACTION, MAX_OPAQUE_SPANS, type DirtyRange } from './globalLegacyBuffer'
 
 export { FULL_DRAW_VISIBLE_FRACTION, MAX_OPAQUE_SPANS as MAX_CUBE_SPANS }
 
@@ -54,10 +48,8 @@ export function buildVisibleCubeSpans(
   } else {
     spans = visibleSlots.map(s => ({ start: s.start, count: s.count }))
     spans.sort((a, b) => a.start - b.start)
-    const liveDrawRanges = spans.map(s => ({ ...s }))
     mergeCubeSpans(spans)
     spans = carveSpansAroundPendingRanges(spans, pendingRanges)
-    assertDrawSpansWithinLiveRanges(spans, liveDrawRanges, 'globalBlockBuffer')
     return spans
   }
   return carveSpansAroundPendingRanges(spans, pendingRanges)

package/src/three/globalBlockBuffer.ts

@@ -711,10 +711,8 @@ export class GlobalBlockBuffer {
       this.finalizePendingReplace(key)
     }
 
-    console.warn('[globalBlockBuffer] growing faces', this.capacityFaces, '->', '(need', minFaces, ')')
     let newCap = this.capacityFaces
     while (newCap < minFaces) newCap += GROWTH_INCREMENT_FACES
-    console.warn('[globalBlockBuffer] growing faces', this.capacityFaces, '->', newCap)
 
     const nw0 = new Uint32Array(newCap)
     const nw1 = new Uint32Array(newCap)

package/src/three/globalLegacyBuffer.ts

@@ -32,33 +32,6 @@ export const FULL_DRAW_VISIBLE_FRACTION = 0.75
 /** Initial multi_draw scratch size; arrays auto-grow — not a draw-call cap. */
 export const MAX_OPAQUE_SPANS = 64
 
-/** Dev assert: every quad in draw spans must lie in a live section's drawable range. */
-export function assertDrawSpansWithinLiveRanges(
-  spans: ReadonlyArray<{ start: number; count: number }>,
-  liveRanges: ReadonlyArray<{ start: number; count: number }>,
-  bufferName: string
-): void {
-  for (const span of spans) {
-    for (let q = span.start; q < span.start + span.count; q++) {
-      let inLive = false
-      for (const live of liveRanges) {
-        if (q >= live.start && q < live.start + live.count) {
-          inLive = true
-          break
-        }
-      }
-      if (!inLive) {
-        console.error('[GlobalLegacyBuffer] draw span covers non-live quad', {
-          buffer: bufferName,
-          quad: q,
-          span,
-          liveRanges
-        })
-      }
-    }
-  }
-}
-
 export type DirtyRange = { start: number; end: number }
 
 /** Split draw spans to exclude quad/face ranges still in pendingRanges (not yet on GPU). */
@@ -481,7 +454,6 @@ export class GlobalLegacyBuffer {
 
     if (mode === 'opaque') {
       let finalQuads: Array<{ start: number; count: number }>
-      const liveDrawRanges = spans.map(s => ({ ...s }))
       const usedFullDraw = this.canUseFullDrawShortcut() && visibleQuadCount >= this.highWatermark * FULL_DRAW_VISIBLE_FRACTION
       if (usedFullDraw) {
         finalQuads = [{ start: 0, count: this.highWatermark }]
@@ -491,9 +463,6 @@ export class GlobalLegacyBuffer {
         finalQuads = spans
       }
       finalQuads = carveSpansAroundPendingRanges(finalQuads, this.pendingRanges)
-      if (!usedFullDraw) {
-        assertDrawSpansWithinLiveRanges(finalQuads, liveDrawRanges, this.mesh.name)
-      }
       for (const span of finalQuads) {
         pushIndexSpan(span.start, span.count)
       }

package/src/three/tests/cubeDrawSpans.test.ts

@@ -2,6 +2,18 @@
 import { describe, expect, test } from 'vitest'
 import { buildVisibleCubeSpans } from '../cubeDrawSpans'
 
+type DrawSpan = { start: number; count: number }
+
+/** Every index in output spans must lie in the union of input section ranges. */
+function expectEveryIndexInUnion(spans: DrawSpan[], sectionRanges: DrawSpan[]): void {
+  for (const span of spans) {
+    for (let i = span.start; i < span.start + span.count; i++) {
+      const inUnion = sectionRanges.some(r => i >= r.start && i < r.start + r.count)
+      expect(inUnion, `index ${i} not in union of section ranges`).toBe(true)
+    }
+  }
+}
+
 describe('buildVisibleCubeSpans', () => {
   test('contiguous slots merge into one span', () => {
     const spans = buildVisibleCubeSpans(
@@ -100,4 +112,23 @@ describe('buildVisibleCubeSpans', () => {
     expect(buildVisibleCubeSpans([], 10)).toEqual([])
     expect(buildVisibleCubeSpans([{ start: 0, count: 1 }], 0)).toEqual([])
   })
+
+  test('merged adjacent sections stay within union of input ranges', () => {
+    const sectionRanges = [
+      { start: 100, count: 10 },
+      { start: 110, count: 10 }
+    ]
+    const spans = buildVisibleCubeSpans(sectionRanges, 120, false)
+    expect(spans).toEqual([{ start: 100, count: 20 }])
+    expectEveryIndexInUnion(spans, sectionRanges)
+  })
+
+  test('carved merged spans stay within union of input ranges', () => {
+    const sectionRanges = [
+      { start: 0, count: 10 },
+      { start: 10, count: 10 }
+    ]
+    const spans = buildVisibleCubeSpans(sectionRanges, 20, false, undefined, [{ start: 5, end: 14 }])
+    expectEveryIndexInUnion(spans, sectionRanges)
+  })
 })

package/src/three/tests/globalLegacyBuffer.test.ts

@@ -701,6 +701,21 @@ test('GlobalLegacyBuffer: carveSpansAroundPendingRanges splits merged span', ()
   ])
 })
 
+test('GlobalLegacyBuffer: carved merged adjacent sections stay within union of input ranges', () => {
+  const sectionRanges = [
+    { start: 100, count: 10 },
+    { start: 110, count: 10 }
+  ]
+  const merged = [{ start: 100, count: 20 }]
+  const carved = carveSpansAroundPendingRanges(merged, [{ start: 105, end: 114 }])
+  for (const span of carved) {
+    for (let q = span.start; q < span.start + span.count; q++) {
+      const inUnion = sectionRanges.some(r => q >= r.start && q < r.start + r.count)
+      expect(inUnion, `quad ${q} not in union of section ranges`).toBe(true)
+    }
+  }
+})
+
 test('GlobalLegacyBuffer: uploadEpoch increments when dirty range drains', () => {
   const scene = new THREE.Scene()
   const mat = createGlobalLegacyBlockMaterial()

package/src/wasm-mesher/bridge/render-from-wasm.ts

@@ -642,7 +642,7 @@ export function renderWasmOutputToGeometry(
         const doAO = (model as { ao?: boolean }).ao ?? cachedModel.boundingBox !== 'empty'
 
         let forceCullMask = 0
-        if (world) {
+        if (world && cachedModel.isCube) {
           const shaderCubeFaceNameToIndex: Record<string, number> = {
             up: 0,
             down: 1,
@@ -787,7 +787,11 @@ export function renderWasmOutputToGeometry(
           const maxy = element.to[1]
           const maxz = element.to[2]
 
-          if (faceIdx !== undefined && (block.visible_faces & (1 << faceIdx)) === 0) {
+          // `visible_faces` is a cell-boundary occlusion mask, so it may only cull faces
+          // that vanilla considers cullable at all — i.e. faces that declare `cullface`.
+          // Inset faces without it (a stair riser) are always drawn. Removing this guard
+          // is what broke issue #81 in 7ce1ebb.
+          if (matchingEFace.cullface && faceIdx !== undefined && (block.visible_faces & (1 << faceIdx)) === 0) {
             continue
           }
 

package/src/wasm-mesher/tests/cullingRegression.test.ts

@@ -14,6 +14,7 @@ import { setBlockStatesData, getSectionGeometry } from '../../mesher-shared/mode
 import { resetFaceOcclusionCache } from '../../mesher-shared/faceOcclusion'
 import { convertChunkToWasm } from '../bridge/convertChunk'
 import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
+import type { ExportedSection } from '../../mesher-shared/exportedGeometryTypes'
 
 const VERSION = '1.18.2'
 const SECTION_Y = 0
@@ -130,6 +131,81 @@ function assertMesherParity(world: World, expectedQuads: number) {
   expect(wasmShader).toBe(expectedQuads)
 }
 
+function renderWasmSection(world: World, shaderCubes = false): ExportedSection {
+  const column = world.getColumn(0, 0)!
+  const conversion = convertChunkToWasm(column, VERSION, 0, 0, SECTION_Y, SECTION_Y + SECTION_HEIGHT, SECTION_Y, SECTION_HEIGHT)
+  const wasmResult = wasmModule.generate_geometry(
+    0,
+    SECTION_Y,
+    0,
+    SECTION_HEIGHT,
+    SECTION_Y,
+    SECTION_Y + SECTION_HEIGHT,
+    SECTION_Y,
+    conversion.blockStates,
+    conversion.blockLight,
+    conversion.skyLight,
+    conversion.biomesArray,
+    conversion.invisibleBlocks,
+    conversion.transparentBlocks,
+    conversion.noAoBlocks,
+    conversion.cullIdenticalBlocks,
+    conversion.occludingBlocks,
+    true,
+    false,
+    15
+  )
+  return renderWasmOutputToGeometry(wasmResult, VERSION, '0,0,0', { x: 8, y: 8, z: 8 }, world, {
+    sectionHeight: SECTION_HEIGHT,
+    shaderCubes
+  })
+}
+
+/** Inset stair riser in cell (bx, by, bz): normal along expectedNx, all four verts on the cell mid-x-plane and within the cell AABB. */
+function hasInsetHorizontalRiser(section: ExportedSection, bx: number, by: number, bz: number, expectedNx: 1 | -1): boolean {
+  const pos = section.geometry.positions
+  const norm = section.geometry.normals
+  const idx = section.geometry.indices
+  const eps = 1e-3
+  const minX = (bx & 15) - 8
+  const maxX = minX + 1
+  const minY = (by & 15) - 8
+  const maxY = minY + 1
+  const minZ = (bz & 15) - 8
+  const maxZ = minZ + 1
+  const riserX = minX + 0.5
+
+  for (let i = 0; i < idx.length; i += 6) {
+    const vertIndices = [...new Set([idx[i], idx[i + 1], idx[i + 2], idx[i + 3], idx[i + 4], idx[i + 5]])]
+    if (vertIndices.length !== 4) continue
+
+    const nx = norm[vertIndices[0]! * 3]!
+    const ny = norm[vertIndices[0]! * 3 + 1]!
+    const nz = norm[vertIndices[0]! * 3 + 2]!
+    if (Math.abs(ny) > eps || Math.abs(nz) > eps) continue
+    if (Math.abs(nx - expectedNx) > eps) continue
+
+    const onRiserPlane = vertIndices.every(vi => Math.abs(pos[vi * 3]! - riserX) < eps)
+    if (!onRiserPlane) continue
+
+    const inCell = vertIndices.every(vi => {
+      const px = pos[vi * 3]!
+      const py = pos[vi * 3 + 1]!
+      const pz = pos[vi * 3 + 2]!
+      return px >= minX - eps && px <= maxX + eps && py >= minY - eps && py <= maxY + eps && pz >= minZ - eps && pz <= maxZ + eps
+    })
+    if (inCell) return true
+  }
+  return false
+}
+
+function stairWithStoneNeighbor(facing: 'east' | 'west' | 'south' | 'north', stone: { x: number; y: number; z: number }): BlockSpec[] {
+  return [
+    { x: 0, y: 0, z: 0, name: 'cut_copper_stairs', props: { facing, half: 'bottom', shape: 'straight', waterlogged: false } },
+    { x: stone.x, y: stone.y, z: stone.z, name: 'stone' }
+  ]
+}
+
 function farmlandFieldBlocks(): BlockSpec[] {
   const blocks: BlockSpec[] = []
   for (let z = 0; z < 16; z++) {
@@ -279,6 +355,32 @@ test('culling regression: glass/leaves cluster — see-through blocks not over-c
   assertMesherParity(world, 20)
 })
 
+test('culling regression: cactus on grass — ground top face not culled (issue #73)', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'grass_block' },
+    { x: 0, y: 1, z: 0, name: 'cactus' }
+  ])
+  // Pre-fix: grass top culled by cactus cosmetic cap → 14 quads. Post-fix: grass top drawn → 15.
+  assertMesherParity(world, 15)
+})
+
+test('culling regression: cactus stacked on cactus — no over-cull holes', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'cactus' },
+    { x: 0, y: 1, z: 0, name: 'cactus' }
+  ])
+  assertMesherParity(world, 12)
+})
+
+test('culling regression: cactus beside solid block — side faces still drawn', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'dirt' },
+    { x: 1, y: 0, z: 0, name: 'cactus' }
+  ])
+  expect(countQuadsFromLegacy(world)).toBeGreaterThan(9)
+  expect(countQuadsFromWasm(world, false)).toBeGreaterThan(9)
+})
+
 test('shader cubes: dirt UP face culled under farmland', () => {
   const world = buildWorld([
     { x: 0, y: 0, z: 0, name: 'dirt' },
@@ -305,3 +407,59 @@ test('shader cubes: dirt side not culled beside bottom slab', () => {
   expect(wasmShader).toBe(legacy)
   expect(wasmShader).toBeGreaterThan(5)
 })
+
+test('culling regression: east-facing stair + stone to east — full silhouette, no inset riser drop (issue #81)', () => {
+  const world = buildWorld(stairWithStoneNeighbor('east', { x: 1, y: 0, z: 0 }))
+  assertMesherParity(world, 14)
+})
+
+test('culling regression: west-facing stair + stone to east — inset riser kept (issue #81)', () => {
+  const world = buildWorld(stairWithStoneNeighbor('west', { x: 1, y: 0, z: 0 }))
+  assertMesherParity(world, 16)
+  expect(hasInsetHorizontalRiser(renderWasmSection(world), 0, 0, 0, 1)).toBe(true)
+})
+
+test('culling regression: south-facing stair + stone to south — inset riser kept (issue #81)', () => {
+  const world = buildWorld(stairWithStoneNeighbor('south', { x: 0, y: 0, z: 1 }))
+  // Tall half faces south toward stone (east/west analog); stone's north face is culled.
+  assertMesherParity(world, 14)
+})
+
+test('culling regression: north-facing stair + stone to south — inset riser kept (issue #81)', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'cut_copper_stairs', props: { facing: 'north', half: 'bottom', shape: 'straight', waterlogged: false } },
+    { x: 0, y: 0, z: 1, name: 'stone' }
+  ])
+  assertMesherParity(world, 16)
+})
+
+test('culling regression: all horizontal facings beside occluding cube — parity table (issue #81)', () => {
+  const cases: Array<{ blocks: BlockSpec[]; quads: number }> = [
+    { blocks: stairWithStoneNeighbor('east', { x: 1, y: 0, z: 0 }), quads: 14 },
+    { blocks: stairWithStoneNeighbor('west', { x: 1, y: 0, z: 0 }), quads: 16 },
+    { blocks: stairWithStoneNeighbor('south', { x: 0, y: 0, z: 1 }), quads: 14 },
+    {
+      blocks: [
+        { x: 0, y: 0, z: 0, name: 'cut_copper_stairs', props: { facing: 'north', half: 'bottom', shape: 'straight', waterlogged: false } },
+        { x: 0, y: 0, z: 1, name: 'stone' }
+      ],
+      quads: 16
+    }
+  ]
+  for (const { blocks, quads } of cases) {
+    assertMesherParity(buildWorld(blocks), quads)
+  }
+})
+
+test('culling regression: sofa scene — acacia stairs risers beside stripped log (issue #81)', () => {
+  const world = buildWorld([
+    { x: 1, y: 0, z: 0, name: 'stripped_acacia_log' },
+    { x: 1, y: 1, z: 0, name: 'acacia_pressure_plate' },
+    { x: 0, y: 0, z: 0, name: 'acacia_stairs', props: { facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false } },
+    { x: 2, y: 0, z: 0, name: 'acacia_stairs', props: { facing: 'east', half: 'bottom', shape: 'straight', waterlogged: false } }
+  ])
+  assertMesherParity(world, 31)
+  const section = renderWasmSection(world)
+  expect(hasInsetHorizontalRiser(section, 0, 0, 0, 1)).toBe(true)
+  expect(hasInsetHorizontalRiser(section, 2, 0, 0, -1)).toBe(true)
+})