@operato/scene-storage 10.0.0-beta.41 → 10.0.0-beta.43

package/test/test-r19-place-absorb.ts

@@ -0,0 +1,174 @@
+/*
+ * R19 — Mover.place 의 *Plan A absorb 미인식* 회귀.
+ *
+ * 결함 시퀀스:
+ *   1. crane.pickAndPlace(externalParcel, rack.slotTargetAt(cellId))
+ *   2. Mover.pick — 외부 parcel 을 crane forks 로
+ *   3. Mover.place:
+ *      a. engage('place') 의 mid-Transfer → SlotTarget.receive → rack.receiveAt
+ *         → parcel.dispose() + state.data.push(record). 여기서 carrier.parent = null.
+ *      b. 후속 검사: `if (carrier.parent === holder) return`
+ *         — holder 는 SlotTarget (wrapper). carrier.parent 는 null. 검사 false → 통과.
+ *      c. canReceive polling 시작: rack.canReceiveAt(cellId) 가 *방금 push 된* record
+ *         때문에 false 영원 반환.
+ *      d. 30s timeout → throw "Mover.place: holder did not become available within 30000ms"
+ *   4. 사용자 script 의 unhandled promise rejection.
+ *
+ * Fix: `Mover.place` 가 *carrier._disposed === true* 검사 추가. absorb 완료 시 polling
+ * 진입 전에 return.
+ */
+
+import 'should'
+
+describe('R19: Mover.place — Plan A absorb 후 30s timeout 결함', () => {
+  it('REPRODUCE — engage 가 carrier 를 *absorb* (dispose) 한 후 polling 에서 멈춤', async () => {
+    // 결함 시뮬: engage 가 carrier 를 dispose (state.data 에 record push). 그러면
+    // canReceive 가 false 영원 → place 가 polling 에서 stuck.
+
+    const carrier: any = {
+      state: { type: 'parcel' },
+      parent: 'mover',
+      _disposed: false
+    }
+    let stateData: any[] = []
+
+    // SlotTarget mock
+    const slotTarget: any = {
+      slotId: 'A',
+      canReceive: (c: any) => !stateData.some(r => r.cellId === 'A'),
+      async receive(c: any) {
+        // absorb: dispose + push record
+        c._disposed = true
+        c.parent = null
+        stateData.push({ cellId: 'A' })
+      }
+    }
+
+    // engage's mid-Transfer 시뮬 — sync executeSync 인 척
+    await slotTarget.receive(carrier)
+    carrier._disposed.should.be.true()
+    stateData.length.should.equal(1)
+
+    // 결함 검증: 후속 *parent === holder* 검사 가 false → polling 진입
+    ;(carrier.parent !== slotTarget).should.be.true()
+
+    // polling: canReceive 영원 false
+    let pollCount = 0
+    const start = Date.now()
+    while (!slotTarget.canReceive(carrier)) {
+      pollCount++
+      if (pollCount > 5) break    // 시뮬용 짧게
+      if (Date.now() - start > 100) break
+      await new Promise(r => setTimeout(r, 10))
+    }
+    pollCount.should.be.greaterThan(1)   // ← 실 환경에선 30s 동안 수백 회
+    console.log(`  → polling 횟수=${pollCount}, canReceive 영원 false (R19 결함 확인)`)
+  })
+
+  it('FIX VERIFY — `_disposed` 검사 가 polling 진입 차단', async () => {
+    const carrier: any = {
+      state: { type: 'parcel' },
+      parent: 'mover',
+      _disposed: false
+    }
+    let stateData: any[] = []
+    const slotTarget: any = {
+      canReceive: () => !stateData.some(r => r.cellId === 'A'),
+      async receive(c: any) {
+        c._disposed = true
+        c.parent = null
+        stateData.push({ cellId: 'A' })
+      }
+    }
+
+    // Simulated Mover.place after-engage
+    await slotTarget.receive(carrier)   // engage's mid-Transfer absorb
+
+    // R19 fix — _disposed 검사:
+    function placeAfterEngage(c: any, holder: any): boolean {
+      if (c.parent === holder) return true      // skip polling
+      if (c._disposed) return true              // R19 fix — absorb 완료
+      return false                              // proceed to polling
+    }
+
+    const shouldSkipPolling = placeAfterEngage(carrier, slotTarget)
+    shouldSkipPolling.should.be.true()    // FIX: polling 진입 X
+  })
+
+  it('FIX VERIFY — disposed 검사 *없으면* polling 영원 (timeout)', () => {
+    const carrier: any = {
+      state: { type: 'parcel' },
+      parent: null,        // absorb 후 null
+      _disposed: true       // absorb 후 disposed
+    }
+    const slotTarget: any = { /* 점유 — canReceive false */ }
+
+    function placeAfterEngage_OLD(c: any, holder: any): boolean {
+      if (c.parent === holder) return true
+      // R19 fix 없음 — polling 진입
+      return false
+    }
+
+    const willPoll = !placeAfterEngage_OLD(carrier, slotTarget)
+    willPoll.should.be.true()   // ← 결함: polling 진입 → 30s timeout 운명
+  })
+})
+
+describe('R19: 사용자 시나리오 — 1차 성공, 2차 명확 에러', () => {
+  it('1차 호출 — 30s timeout 없이 즉시 완료', async () => {
+    const carrier: any = {
+      state: { type: 'parcel', id: 'parcel' },
+      parent: 'mover',
+      _disposed: false
+    }
+    let stateData: any[] = []
+    const slot: any = {
+      canReceive: () => !stateData.some(r => r.cellId === 'A'),
+      async receive(c: any) {
+        c._disposed = true
+        c.parent = null
+        stateData.push({ cellId: 'A' })
+      }
+    }
+
+    // Mover.place (R19 fix 포함)
+    async function moverPlace(c: any, holder: any): Promise<void> {
+      await holder.receive(c)
+      if (c.parent === holder) return
+      if (c._disposed) return    // R19 fix
+      // polling (도달하지 않아야 함)
+      throw new Error('polling reached — R19 fix not applied')
+    }
+
+    const started = Date.now()
+    await moverPlace(carrier, slot)
+    const elapsed = Date.now() - started
+
+    elapsed.should.be.lessThan(100)   // 즉시 완료 (no 30s)
+    stateData.length.should.equal(1)
+    carrier._disposed.should.be.true()
+  })
+
+  it('2차 호출 — disposed carrier 로 R18 가 *즉시 throw*', async () => {
+    const disposedCarrier: any = {
+      state: { type: 'parcel', id: 'parcel' },
+      parent: null,
+      _disposed: true   // 이미 1차에서 dispose 됨
+    }
+
+    // Mover.pickAndPlace 의 R18 guard
+    function pickAndPlaceR18Check(c: any): void {
+      if (c._disposed) {
+        throw new Error('Mover.pickAndPlace: carrier is already disposed.')
+      }
+    }
+
+    let thrown: any
+    try {
+      pickAndPlaceR18Check(disposedCarrier)
+    } catch (e) { thrown = e }
+
+    thrown.should.not.be.null()
+    thrown.message.should.match(/disposed/)
+  })
+})

package/test/test-rack-3d-attach-real.ts

@@ -0,0 +1,301 @@
+/*
+ * Plan A 의 *진짜 Three.js* attach/detach 검증.
+ *
+ * 가짜 Object3D 대신 *실제 THREE.Object3D + Mesh + Group* 으로 ghost 와 텔레포트 의
+ * 원인 (Three.js scene graph 의 parent 추적 누락) 을 직접 확인.
+ *
+ * 시나리오:
+ *   1. carrier 의 Three.js parent transition: 없음 → slot anchor → crane fork → 없음
+ *   2. receiveAt 이 *실제로* object3d 를 scene graph 에서 분리하는지
+ *   3. 새 carrier 가 같은 cellId 로 obtain 됐을 때 *이전 instance 의 mesh 가 잔존하지
+ *      않는지* (ghost regression)
+ */
+
+import 'should'
+import * as THREE from 'three'
+
+// ── 실제 things-scene 의 Carriable / RealObject 정신을 가능한 한 가깝게 모사 ─────
+
+class RealCarrier {
+  state: any
+  parent: any = null
+  _realObject: { object3d: THREE.Object3D }
+  _disposed = false
+
+  constructor(state: any) {
+    this.state = state
+    // Parcel3D 처럼 *child mesh 가 있는 Group* 으로 — real 환경 모방
+    const group = new THREE.Group()
+    group.name = `parcel-${state.id ?? state.cellId ?? '?'}-group`
+    const bodyMesh = new THREE.Mesh(
+      new THREE.BoxGeometry(50, 50, 50),
+      new THREE.MeshBasicMaterial({ color: 0xc8a878 })
+    )
+    bodyMesh.name = 'parcel-body'
+    group.add(bodyMesh)
+    this._realObject = { object3d: group }
+  }
+
+  applyHolderAttachPoint(): void {
+    const p: any = this.parent
+    if (!p?.attachPointFor) return
+    const point = p.attachPointFor(this)
+    if (!point?.attach) return
+    point.attach.attach(this._realObject.object3d)
+    if (point.localPosition) {
+      this._realObject.object3d.position.set(
+        point.localPosition.x, point.localPosition.y, point.localPosition.z
+      )
+    }
+  }
+
+  dispose(): void {
+    this._disposed = true
+    // RealObject.dispose 의 clear() 모방 — children 정리, object3d 자체는 안 떼는 결함
+    for (const child of [...this._realObject.object3d.children]) {
+      const mesh = child as THREE.Mesh
+      mesh.geometry?.dispose?.()
+      const mats = Array.isArray(mesh.material) ? mesh.material : (mesh.material ? [mesh.material] : [])
+      for (const m of mats) m?.dispose?.()
+    }
+    this._realObject.object3d.clear()
+  }
+}
+
+class RealRack {
+  state: any = { data: [] }
+  components: any[] = []
+  rootObject3d = new THREE.Group()
+  _slotAnchors = new Map<string, THREE.Object3D>()
+
+  constructor() { this.rootObject3d.name = 'rack-root' }
+
+  ensureSlotAnchor(cellId: string): THREE.Object3D {
+    let a = this._slotAnchors.get(cellId)
+    if (!a) {
+      a = new THREE.Object3D()
+      a.name = `slot:${cellId}`
+      this.rootObject3d.add(a)
+      this._slotAnchors.set(cellId, a)
+    }
+    return a
+  }
+
+  addComponent(c: any): void { c.parent = this; this.components.push(c) }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+
+  attachPointFor(carrier: any) {
+    const cellId = carrier.state.cellId
+    return { attach: this.ensureSlotAnchor(cellId), localPosition: { x: 0, y: 0, z: 0 } }
+  }
+
+  obtainCarrier(cellId: string): RealCarrier | null {
+    const i = this.state.data.findIndex((r: any) => r.cellId === cellId)
+    if (i === -1) return null
+    const record = this.state.data[i]
+    const c = new RealCarrier({ ...record, cellId })
+    this.addComponent(c)
+    c.applyHolderAttachPoint()
+    this.state.data = this.state.data.filter((_: any, j: number) => j !== i)
+    return c
+  }
+
+  async receiveAt(cellId: string, carrier: RealCarrier): Promise<void> {
+    // Plan A flow:
+    // 1. removeComponent
+    const p = carrier.parent
+    if (p?.removeComponent) p.removeComponent(carrier)
+
+    // 2. 명시적 Three.js detach (RealObject.dispose 만으로 안 떼는 part 보완)
+    const obj = carrier._realObject?.object3d
+    if (obj?.parent?.remove) obj.parent.remove(obj)
+
+    // 3. dispose
+    carrier.dispose()
+
+    // 4. record push
+    const rec: any = { cellId, type: carrier.state.type ?? 'parcel' }
+    for (const k of Object.keys(carrier.state)) {
+      if (['id', 'left', 'top', 'zPos', 'cellId'].includes(k)) continue
+      rec[k] = carrier.state[k]
+    }
+    this.state.data.push(rec)
+  }
+}
+
+class RealCrane {
+  components: any[] = []
+  forkObject3d = new THREE.Object3D()
+  constructor() { this.forkObject3d.name = 'crane-fork' }
+  addComponent(c: any): void { c.parent = this; this.components.push(c) }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+  simulatePick(c: any): void {
+    const op = c.parent
+    if (op?.removeComponent) op.removeComponent(c)
+    this.addComponent(c)
+    this.forkObject3d.attach(c._realObject.object3d)
+    c._realObject.object3d.position.set(0, 0, 0)
+  }
+}
+
+// ── Group 1: Three.js scene graph 의 parent transition ────────────────────────
+
+describe('Real Three.js: carrier scene-graph parent transitions', () => {
+  it('갓 생성 — object3d.parent === null', () => {
+    const c = new RealCarrier({ cellId: 'X' })
+    ;(c._realObject.object3d.parent === null).should.be.true()
+  })
+
+  it('obtainCarrier 후 — object3d.parent.name === slot:A-0-1', () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A-0-1' }]
+    const c = rack.obtainCarrier('A-0-1')!
+    c._realObject.object3d.parent!.name.should.equal('slot:A-0-1')
+  })
+
+  it('crane.simulatePick 후 — object3d.parent.name === crane-fork', () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+    c._realObject.object3d.parent!.name.should.equal('crane-fork')
+  })
+
+  it('receiveAt 후 — object3d.parent === null (완전 detach)', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+    await rack.receiveAt('B', c)
+    ;(c._realObject.object3d.parent === null).should.be.true()
+  })
+})
+
+// ── Group 2: ghost 검증 — receiveAt 후 visible mesh 잔존 X ───────────────────
+
+describe('Real Three.js: ghost 없음', () => {
+  it('receiveAt 후 — crane fork 의 자식에 아무도 없음 (mover idle)', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    crane.forkObject3d.children.length.should.equal(1)   // 들고 있는 동안
+
+    await rack.receiveAt('B', c)
+    crane.forkObject3d.children.length.should.equal(0)   // 내려놓은 후 비어있음
+  })
+
+  it('receiveAt 후 — slot anchor (source) 의 자식 비어있음', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const sourceAnchor = rack.ensureSlotAnchor('A')
+
+    const c = rack.obtainCarrier('A')!
+    sourceAnchor.children.length.should.equal(1)   // obtain 직후 attached
+
+    crane.simulatePick(c)
+    sourceAnchor.children.length.should.equal(0)   // pick 후 source 비어있음
+  })
+
+  it('receiveAt 후 — dest slot anchor 에도 아무것도 없음 (record 만 있을 뿐)', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+    await rack.receiveAt('B', c)
+
+    // B 의 anchor 는 미리 생성되어 있을 수도 / 없을 수도. 어쨌든 carrier 의 object3d 는 거기 없음
+    const bAnchor = rack._slotAnchors.get('B')
+    if (bAnchor) bAnchor.children.length.should.equal(0)
+    // record 는 state.data 에 있어야 함
+    rack.state.data.length.should.equal(1)
+    rack.state.data[0].cellId.should.equal('B')
+  })
+
+  it('carrier 의 *mesh children* 도 정리됨 (geometry/material disposed)', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new RealCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    const bodyMesh = c._realObject.object3d.children[0] as THREE.Mesh
+    // dispose 전엔 살아있음
+    bodyMesh.should.not.be.undefined()
+
+    await rack.receiveAt('B', c)
+
+    // carrier object3d 자체는 empty Group
+    c._realObject.object3d.children.length.should.equal(0)
+  })
+})
+
+// ── Group 3: 반복 pickAndPlace — ghost 누적 없음 ─────────────────────────────
+
+describe('Real Three.js: 반복 pickAndPlace 회귀 차단', () => {
+  it('A→B 10번 왕복 — crane fork 와 두 slot anchor 가 매 사이클마다 깨끗', async () => {
+    const rack = new RealRack()
+    rack.state.data = [{ cellId: 'A', sku: 'X' }]
+    const crane = new RealCrane()
+    const anchorA = rack.ensureSlotAnchor('A')
+    const anchorB = rack.ensureSlotAnchor('B')
+
+    for (let i = 0; i < 10; i++) {
+      // A → B
+      const cAB = rack.obtainCarrier('A')!
+      cAB.should.not.be.null()
+      crane.simulatePick(cAB)
+      await rack.receiveAt('B', cAB)
+      crane.forkObject3d.children.length.should.equal(0)
+      anchorA.children.length.should.equal(0)
+      anchorB.children.length.should.equal(0)
+
+      // B → A
+      const cBA = rack.obtainCarrier('B')!
+      cBA.should.not.be.null()
+      crane.simulatePick(cBA)
+      await rack.receiveAt('A', cBA)
+      crane.forkObject3d.children.length.should.equal(0)
+      anchorA.children.length.should.equal(0)
+      anchorB.children.length.should.equal(0)
+    }
+
+    // 끝에 정확히 1 record at A
+    rack.state.data.length.should.equal(1)
+    rack.state.data[0].cellId.should.equal('A')
+    rack.state.data[0].sku.should.equal('X')
+  })
+
+  it('대량 데이터 (100 records) — 모두 다른 dest 로 이동, ghost X', async () => {
+    const rack = new RealRack()
+    rack.state.data = Array.from({ length: 100 }, (_, i) => ({ cellId: `src-${i}`, sku: `S${i}` }))
+    const crane = new RealCrane()
+
+    for (let i = 0; i < 100; i++) {
+      const c = rack.obtainCarrier(`src-${i}`)!
+      crane.simulatePick(c)
+      await rack.receiveAt(`dst-${i}`, c)
+    }
+
+    rack.state.data.length.should.equal(100)
+    rack.state.data.every((r: any) => r.cellId.startsWith('dst-')).should.be.true()
+    crane.components.length.should.equal(0)
+    crane.forkObject3d.children.length.should.equal(0)
+    // 모든 src anchor 와 dst anchor 의 자식 0
+    for (const [, a] of rack._slotAnchors) a.children.length.should.equal(0)
+  })
+})