@operato/scene-storage 10.0.0-beta.40 → 10.0.0-beta.42

package/test/test-crane-geometry.ts

@@ -0,0 +1,167 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * Crane 3D 의 기하학 공식 정합 검증 — *pure* unit test.
+ *
+ * 시뮬 시각 결함 진단 위한 *수학적 정합 sanity check*. carrier 위치/자세
+ * 결함이 *기하학 공식 mismatch* 인지 *3D scene-graph 의 다른 결함* 인지
+ * 좁힘.
+ *
+ * Forward 공식 (Crane3D.build):
+ *   carriageH = S * 0.12 (S = min(width, height))
+ *   bladeH    = carriageH * 0.35
+ *   liftGroup.y crane-local = baseTrolleyY + baseH/2 + carriageHeight + forkLift + carriageH/2
+ *   _carrierBaseY (liftGroup-local) = -bladeH/2  (fork blade bottom)
+ *   carrier 외부 bottom crane-local = liftGroup.y + _carrierBaseY
+ *   carrier 외부 bottom world Y    = craneCenterWorldY + crane-local
+ *
+ * Inverse (Crane3D.solveCarriageHeightForCarrierBaseWorldY):
+ *   carriageHeight = worldY − craneCenterY − (baseTrolleyY + baseH/2 + carriageH/2 − bladeH/2) − forkLift
+ */
+
+import 'should'
+
+interface CraneParams {
+  S: number       // min(width, height)
+  D: number       // depth
+}
+
+interface DerivedParams {
+  carriageH: number
+  bladeH: number
+  baseH: number
+  railH: number
+  baseTrolleyY: number  // crane-local (= -D/2 + railH + baseH/2)
+}
+
+function derive(p: CraneParams): DerivedParams {
+  const carriageH = p.S * 0.12
+  const bladeH = carriageH * 0.35
+  const baseH = p.S * 0.18
+  const railH = p.S * 0.04
+  const baseTrolleyY = -p.D / 2 + railH + baseH / 2
+  return { carriageH, bladeH, baseH, railH, baseTrolleyY }
+}
+
+// Forward: build 공식
+function carrierBaseWorldY(
+  d: DerivedParams,
+  carriageHeight: number,
+  forkLift: number,
+  craneCenterY: number
+): number {
+  const liftGroupY = d.baseTrolleyY + d.baseH / 2 + carriageHeight + forkLift + d.carriageH / 2
+  const carrierBaseLocal = liftGroupY + (-d.bladeH / 2)
+  return craneCenterY + carrierBaseLocal
+}
+
+// Inverse: solveCarriageHeightForCarrierBaseWorldY
+function solveCarriageHeight(
+  d: DerivedParams,
+  carrierBaseWorld: number,
+  forkLift: number,
+  craneCenterY: number
+): number {
+  return carrierBaseWorld - craneCenterY - (d.baseTrolleyY + d.baseH / 2 + d.carriageH / 2 - d.bladeH / 2) - forkLift
+}
+
+describe('Crane3D — geometry roundtrip', () => {
+  const params: CraneParams = { S: 400, D: 1000 }
+  const d = derive(params)
+
+  it('derived parameter values', () => {
+    d.carriageH.should.be.approximately(48, 0.001)
+    d.bladeH.should.be.approximately(16.8, 0.001)
+    d.baseH.should.be.approximately(72, 0.001)
+    d.railH.should.be.approximately(16, 0.001)
+    // baseTrolleyY = -500 + 16 + 36 = -448
+    d.baseTrolleyY.should.be.approximately(-448, 0.001)
+  })
+
+  it('forward → inverse roundtrip — forkLift=0', () => {
+    const craneCenterY = 0
+    const forkLift = 0
+    for (const ch of [0, 100, 200, 500, 800]) {
+      const baseWorld = carrierBaseWorldY(d, ch, forkLift, craneCenterY)
+      const recovered = solveCarriageHeight(d, baseWorld, forkLift, craneCenterY)
+      recovered.should.be.approximately(ch, 0.001)
+    }
+  })
+
+  it('forward → inverse roundtrip — forkLift>0 (들린 상태)', () => {
+    const craneCenterY = 0
+    const forkLift = 30
+    for (const ch of [0, 100, 500]) {
+      const baseWorld = carrierBaseWorldY(d, ch, forkLift, craneCenterY)
+      const recovered = solveCarriageHeight(d, baseWorld, forkLift, craneCenterY)
+      recovered.should.be.approximately(ch, 0.001)
+    }
+  })
+
+  it('forward → inverse — craneCenterY 보정 (crane.zPos != 0)', () => {
+    const craneCenterY = 250
+    const forkLift = 0
+    const ch = 100
+    const baseWorld = carrierBaseWorldY(d, ch, forkLift, craneCenterY)
+    const recovered = solveCarriageHeight(d, baseWorld, forkLift, craneCenterY)
+    recovered.should.be.approximately(ch, 0.001)
+  })
+})
+
+describe('Crane3D — pick 시퀀스 기하학', () => {
+  const params: CraneParams = { S: 400, D: 1000 }
+  const d = derive(params)
+  const craneCenterY = 0
+
+  it('pick 진입: carriageHeight 산출 → carrier 외부 bottom = cellBottom', () => {
+    const cellBottom = 100   // cell shelf 면 world Y
+    const forkLift = 0       // pick 진입 시 forkLift 0
+
+    const carriageHeight = solveCarriageHeight(d, cellBottom, forkLift, craneCenterY)
+    const baseWorld = carrierBaseWorldY(d, carriageHeight, forkLift, craneCenterY)
+
+    baseWorld.should.be.approximately(cellBottom, 0.001)
+  })
+
+  it('pick lift 후: forkLift = liftH → carrier 외부 bottom = cellBottom + liftH', () => {
+    const cellBottom = 100
+    const liftH = 30
+    // 진입 carriageHeight (forkLift=0)
+    const ch = solveCarriageHeight(d, cellBottom, 0, craneCenterY)
+    // lift 후 forkLift = liftH, carriageHeight 그대로
+    const liftedBaseWorld = carrierBaseWorldY(d, ch, liftH, craneCenterY)
+    liftedBaseWorld.should.be.approximately(cellBottom + liftH, 0.001)
+  })
+})
+
+describe('Crane3D — place 시퀀스 기하학', () => {
+  const params: CraneParams = { S: 400, D: 1000 }
+  const d = derive(params)
+  const craneCenterY = 0
+
+  it('place 진입 (holding): approachWorldY = cellBottom + liftH', () => {
+    const cellBottom = 200   // 다른 cell
+    const liftH = 30
+    const forkLiftRT = liftH  // 들린 상태로 도착
+
+    // approachWorldY = cellBottom + liftH (holding 보정)
+    const approachWorldY = cellBottom + liftH
+
+    const carriageHeight = solveCarriageHeight(d, approachWorldY, forkLiftRT, craneCenterY)
+    const baseWorld = carrierBaseWorldY(d, carriageHeight, forkLiftRT, craneCenterY)
+
+    baseWorld.should.be.approximately(approachWorldY, 0.001)
+  })
+
+  it('place lower 후: forkLift = 0 → carrier 외부 bottom = cellBottom', () => {
+    const cellBottom = 200
+    const liftH = 30
+    const approachWorldY = cellBottom + liftH
+
+    const ch = solveCarriageHeight(d, approachWorldY, liftH, craneCenterY)
+    // lower 후 forkLift = 0
+    const loweredBaseWorld = carrierBaseWorldY(d, ch, 0, craneCenterY)
+
+    loweredBaseWorld.should.be.approximately(cellBottom, 0.001)
+  })
+})

package/test/test-external-to-rack.ts

@@ -0,0 +1,461 @@
+/*
+ * 외부 (model-layer) 패키지 → Rack 내부로의 pickAndPlace 검증.
+ *
+ * 사용자 질문:
+ *   1. 외부 → 내부 프로세스가 *완전히* 검증됐나?
+ *   2. 한 번 옮긴 후 *같은 외부 위치에서 또 가져오려 시도* 하는 결함 — dispose 가 정상인가?
+ *
+ * 검증:
+ *   - 외부 parcel 의 lifecycle: model-layer 자식 → pick → crane 자식 → place → dispose
+ *   - dispose 후 *id 인덱스 / findById / parent reference 모두 정리되어야*
+ *   - 두 번째 pickAndPlace 시도 → 같은 parcel reference 가 *유효하지 않아야*
+ *   - state.data 에 record 로 환원되어 다시 obtain 가능해야 함
+ */
+
+import 'should'
+import * as THREE from 'three'
+
+// ── Mini scene: root + model-layer + rack + crane ──────────────────────────
+
+class MiniRoot {
+  components: any[] = []
+  _idIndex = new Map<string, any>()
+
+  addComponent(c: any): void {
+    c.parent = this
+    this.components.push(c)
+    if (c.state?.id) this._idIndex.set(c.state.id, c)
+    // children recursive add
+    for (const child of c.components ?? []) {
+      this.addComponent(child)
+    }
+  }
+
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    if (c.state?.id) this._idIndex.delete(c.state.id)
+    c.parent = null
+  }
+
+  // Recursive — descendant 도 id 등록
+  _registerDescendants(c: any): void {
+    if (c.state?.id) this._idIndex.set(c.state.id, c)
+    for (const child of c.components ?? []) this._registerDescendants(child)
+  }
+  _unregisterDescendants(c: any): void {
+    if (c.state?.id) this._idIndex.delete(c.state.id)
+    for (const child of c.components ?? []) this._unregisterDescendants(child)
+  }
+
+  findById(id: string): any { return this._idIndex.get(id) ?? null }
+}
+
+class MiniModelLayer {
+  parent: any = null
+  components: any[] = []
+  state = { id: 'model-layer' }
+  object3d = new THREE.Group()
+
+  constructor() { this.object3d.name = 'model-layer' }
+
+  addComponent(c: any): void {
+    c.parent = this
+    this.components.push(c)
+    if (c._realObject?.object3d) this.object3d.attach(c._realObject.object3d)
+    // root index sync
+    const root = this._findRoot()
+    if (root) root._registerDescendants(c)
+  }
+
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+    const root = this._findRoot()
+    if (root) root._unregisterDescendants(c)
+  }
+
+  _findRoot(): MiniRoot | null {
+    let p: any = this.parent
+    while (p && !(p instanceof MiniRoot)) p = p.parent
+    return p as MiniRoot ?? null
+  }
+
+  canReceive(_c: any): boolean { return true }
+  async receive(c: any): Promise<void> {
+    const p = c.parent
+    if (p?.removeComponent) p.removeComponent(c)
+    this.addComponent(c)
+  }
+}
+
+class MiniRack {
+  parent: any = null
+  state: any = { id: 'rack', data: [] }
+  components: any[] = []
+  object3d = new THREE.Group()
+  _slotAnchors = new Map<string, THREE.Object3D>()
+
+  constructor() { this.object3d.name = 'rack' }
+
+  records(): any[] { return this.state.data }
+  carrierAt(cellId: string): any {
+    return this.components.find(c => c.placement === 'operation' && c.state?.cellId === cellId)
+  }
+  canReceiveAt(cellId: string, carrier?: any): boolean {
+    if (this.records().some(r => r?.cellId === cellId)) return false
+    const existing = this.carrierAt(cellId)
+    if (existing && existing !== carrier) return false
+    return true
+  }
+
+  addComponent(c: any): void {
+    c.parent = this
+    this.components.push(c)
+    const root = (this.parent as MiniModelLayer)?._findRoot?.()
+    if (root) root._registerDescendants(c)
+  }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+    const root = (this.parent as MiniModelLayer)?._findRoot?.()
+    if (root) root._unregisterDescendants(c)
+  }
+
+  ensureSlotAnchor(cellId: string): THREE.Object3D {
+    let a = this._slotAnchors.get(cellId)
+    if (!a) {
+      a = new THREE.Object3D()
+      a.name = `slot:${cellId}`
+      this.object3d.add(a)
+      this._slotAnchors.set(cellId, a)
+    }
+    return a
+  }
+
+  slotTargetAt(cellId: string): any {
+    const rack = this
+    return {
+      slotId: cellId,
+      holder: rack,
+      canReceive: (c: any) => rack.canReceiveAt(cellId, c),
+      async receive(c: any) { await rack.receiveAt(cellId, c) }
+    }
+  }
+
+  async receiveAt(cellId: string, carrier: any): Promise<void> {
+    if (!this.canReceiveAt(cellId, carrier)) {
+      const err: any = new Error('slot occupied')
+      err.reason = 'slot-occupied'
+      throw err
+    }
+    const p = carrier.parent
+    if (p?.removeComponent) p.removeComponent(carrier)
+    const obj = carrier._realObject?.object3d
+    if (obj?.parent?.remove) obj.parent.remove(obj)
+    carrier.dispose?.()
+    const rec: any = { cellId, type: carrier.state.type ?? 'parcel', sku: carrier.state.sku }
+    const remaining = this.records().filter(r => r?.cellId !== cellId)
+    this.state.data = [...remaining, rec]
+  }
+
+  obtainCarrier(cellId: string): any {
+    const existing = this.carrierAt(cellId)
+    if (existing) return existing
+    const records = this.records()
+    const idx = records.findIndex(r => r?.cellId === cellId)
+    if (idx === -1) return null
+    const record = records[idx]
+    const c: any = {
+      placement: 'operation',
+      state: { ...record, cellId },   // id 명시 안 함 → 새 transient (외부 parcel 과 다른 객체)
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() {
+        this._disposed = true
+        if (this._realObject?.object3d?.parent?.remove) {
+          this._realObject.object3d.parent.remove(this._realObject.object3d)
+        }
+        this._realObject.object3d.clear()
+      }
+    }
+    this.addComponent(c)
+    const pt = this.ensureSlotAnchor(cellId)
+    pt.attach(c._realObject.object3d)
+    c._realObject.object3d.position.set(0, 0, 0)
+    this.state.data = records.filter(r => r?.cellId !== cellId)
+    return c
+  }
+}
+
+class MiniCrane {
+  parent: any = null
+  state = { id: 'crane' }
+  components: any[] = []
+  object3d = new THREE.Group()
+  forkObject3d: THREE.Object3D
+  constructor() {
+    this.object3d.name = 'crane'
+    this.forkObject3d = new THREE.Object3D()
+    this.forkObject3d.name = 'crane-fork'
+    this.object3d.add(this.forkObject3d)
+  }
+  canReceive(_c: any): boolean {
+    return this.components.filter(c => c._transferSlotId === 'forks').length < 1
+  }
+  async receive(c: any): Promise<void> {
+    if (!this.canReceive(c)) {
+      const err: any = new Error('crane full')
+      err.reason = 'all-slots-full'
+      throw err
+    }
+    const op = c.parent
+    if (op?.removeComponent) op.removeComponent(c)
+    c.parent = this
+    this.components.push(c)
+    c._transferSlotId = 'forks'
+    const obj = c._realObject?.object3d
+    if (obj) {
+      if (obj.parent?.remove) obj.parent.remove(obj)
+      this.forkObject3d.attach(obj)
+      obj.position.set(0, 0, 0)
+    }
+  }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+  async dispatch(c: any, target: any): Promise<void> {
+    if (target.canReceive && !target.canReceive(c)) {
+      const err: any = new Error('target rejected')
+      err.reason = 'cannot-receive'
+      throw err
+    }
+    delete c._transferSlotId
+    if (typeof target.receive === 'function') await target.receive(c)
+  }
+  async pickAndPlace(carrier: any, target: any, options: { timeoutMs?: number } = {}): Promise<void> {
+    // R18 guard — disposed carrier 재사용 차단
+    if (carrier?._disposed) {
+      throw new Error('Mover.pickAndPlace: carrier is already disposed')
+    }
+    const sourceParent: any = carrier.parent
+    try {
+      if (carrier.parent !== this) await this.receive(carrier)
+      const timeoutMs = options.timeoutMs ?? 1000
+      const started = Date.now()
+      while (target.canReceive && !target.canReceive(carrier)) {
+        if (Date.now() - started > timeoutMs) throw new Error(`place timeout`)
+        await new Promise(r => setTimeout(r, 5))
+      }
+      await this.dispatch(carrier, target)
+    } catch (err) {
+      if (this.components.includes(carrier)) {
+        if (sourceParent?.canReceive?.(carrier)) {
+          try { await this.dispatch(carrier, sourceParent) } catch {}
+        } else {
+          this.removeComponent(carrier)
+        }
+      }
+      throw err
+    }
+  }
+}
+
+function buildScene() {
+  const root = new MiniRoot()
+  const modelLayer = new MiniModelLayer()
+  const rack = new MiniRack()
+  const crane = new MiniCrane()
+  root.addComponent(modelLayer)
+  modelLayer.parent = root
+  rack.parent = modelLayer
+  modelLayer.components.push(rack)
+  if (rack.state?.id) root._idIndex.set(rack.state.id, rack)
+  crane.parent = modelLayer
+  modelLayer.components.push(crane)
+  if (crane.state?.id) root._idIndex.set(crane.state.id, crane)
+  return { root, modelLayer, rack, crane }
+}
+
+// ── Group 1: 외부 → 내부 pickAndPlace 기본 흐름 ─────────────────────────────
+
+describe('External → Rack: 기본 흐름 검증', () => {
+  it('parcel (model-layer 자식) → rack slot — state.data 에 record 추가', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel', sku: 'X' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() {
+        this._disposed = true
+        if (this._realObject?.object3d?.parent?.remove) this._realObject.object3d.parent.remove(this._realObject.object3d)
+        this._realObject.object3d.clear()
+      }
+    }
+    modelLayer.addComponent(parcel)
+
+    root.findById('parcel').should.equal(parcel)
+    modelLayer.components.includes(parcel).should.be.true()
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+
+    // 검증: rack 의 state.data 에 record 가 있어야 함
+    rack.records().length.should.equal(1)
+    rack.records()[0].cellId.should.equal('A')
+    rack.records()[0].sku.should.equal('X')
+
+    // parcel 은 dispose 됐어야 함
+    parcel._disposed.should.be.true()
+    ;(parcel.parent === null).should.be.true()
+  })
+
+  it('FIX 검증 — dispose 후 findById 가 *parcel 을 못 찾아야*', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    modelLayer.addComponent(parcel)
+
+    root.findById('parcel').should.equal(parcel)   // 시작 — 찾을 수 있음
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+
+    // *결정적 검증* — dispose 후엔 못 찾아야 함
+    ;(root.findById('parcel') === null).should.be.true()
+  })
+
+  it('parcel.object3d 가 *완전히 detach* — model-layer / crane / rack 어디에도 없음', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel' },
+      parent: null,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() {
+        if (this._realObject?.object3d?.parent?.remove) this._realObject.object3d.parent.remove(this._realObject.object3d)
+        this._realObject.object3d.clear()
+      }
+    }
+    modelLayer.addComponent(parcel)
+    parcel._realObject.object3d.parent!.name.should.equal('model-layer')
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+
+    ;(parcel._realObject.object3d.parent === null).should.be.true()
+    crane.forkObject3d.children.length.should.equal(0)
+    modelLayer.object3d.children.includes(parcel._realObject.object3d).should.be.false()
+  })
+})
+
+// ── Group 2: dispose 후 *다시* pickAndPlace 시도 ────────────────────────────
+
+describe('External → Rack: dispose 후 reference 재사용', () => {
+  it('R18 FIX VERIFY — disposed parcel 로 또 pickAndPlace 시도 → *즉시 throw*', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    modelLayer.addComponent(parcel)
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+    parcel._disposed.should.be.true()
+    rack.records().length.should.equal(1)
+    rack.records()[0].cellId.should.equal('A')
+
+    // 두 번째 시도 — disposed reference 로 → R18 fix 가 *즉시 throw*
+    let thrown: any
+    try {
+      await crane.pickAndPlace(parcel, rack.slotTargetAt('B'), { timeoutMs: 200 })
+    } catch (e) { thrown = e }
+
+    thrown.should.not.be.null()
+    thrown.message.should.match(/disposed/i)
+    // 좀비 작업 안 일어남 — state.data 그대로
+    rack.records().length.should.equal(1)
+    rack.records()[0].cellId.should.equal('A')
+    // crane 안 움직임
+    crane.components.length.should.equal(0)
+  })
+
+  it('FIX REQUIRED — dispose 된 carrier 는 *재사용 reject 되어야*', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    modelLayer.addComponent(parcel)
+
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+
+    // *원하는 동작* — disposed carrier 로 호출 시 명시 reject
+    // 현재 구현엔 _disposed 검사가 없음. 사용자 script 가 disposed reference 를 갖고
+    // 또 호출하면 *조용히 새 carrier 처럼 작동* 함 — 사용자가 "왜 같은 외부에서 또
+    // 가져오려 하나" 라고 느끼는 정체.
+    parcel._disposed.should.be.true()
+
+    // 사용자가 *해야 할 일* — 두 번째에선 obtainCarrier 로 *새 transient* 를 가져와야 함
+    const newCarrier = rack.obtainCarrier('A')
+    newCarrier.should.not.be.null()
+    newCarrier!.state.cellId.should.equal('A')
+    ;(newCarrier!._disposed !== true).should.be.true()
+  })
+})
+
+// ── Group 3: pickAndPlace 후 *rack 내부 record 로 다시 obtain* ──────────────
+
+describe('External → Rack → 다시 외부로 (round trip)', () => {
+  it('외부 parcel → rack 진입 → 다시 obtainCarrier → 새 transient — 원본 X', async () => {
+    const { root, modelLayer, rack, crane } = buildScene()
+    const parcel: any = {
+      placement: 'operation',
+      state: { id: 'parcel', type: 'parcel', sku: 'X' },
+      parent: null,
+      _disposed: false,
+      _realObject: { object3d: new THREE.Group() },
+      dispose() { this._disposed = true; this._realObject.object3d.clear() }
+    }
+    modelLayer.addComponent(parcel)
+
+    // 1. 외부 → 내부
+    await crane.pickAndPlace(parcel, rack.slotTargetAt('A'), { timeoutMs: 200 })
+    parcel._disposed.should.be.true()
+    rack.records().length.should.equal(1)
+
+    // 2. 내부 → (다시) 새 외부 위치로 — obtainCarrier 로 새 transient
+    const newCarrier = rack.obtainCarrier('A')!
+    newCarrier.should.not.equal(parcel)        // 원본과 다른 객체
+    newCarrier._disposed.should.equal(false)
+    newCarrier.state.sku.should.equal('X')     // 데이터 보존
+
+    // 3. 새 transient 를 model-layer 등 외부로 보냄
+    await crane.pickAndPlace(newCarrier, modelLayer, { timeoutMs: 200 })
+
+    // 사용자가 보는 결과:
+    //   - rack.records 비어있음 (carrier 가 외부로 떠났음)
+    //   - newCarrier 는 model-layer 의 자식
+    rack.records().length.should.equal(0)
+    modelLayer.components.includes(newCarrier).should.be.true()
+    newCarrier.state.sku.should.equal('X')
+  })
+})