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

package/test/test-rack-grid-picking-position.ts

@@ -0,0 +1,154 @@
+/*
+ * RackGrid — picking 위치 정밀 검증.
+ *
+ * 사용자 보고: obtainCarrier 가 만든 carrier 가 *3D 에서 보이는 stock 자리* 와
+ * 다른 위치에 picking 됨.
+ *
+ * 가설: stock InstancedMesh 의 3D 위치 식 (rack-grid-3d.ts:359-363) 과 내가
+ * 새로 작성한 obtainCarrier 의 carrier 좌표 식 (rack-grid.ts) 이 *서로 다른
+ * 좌표계 / 다른 분할 방식* 을 사용해 동일 cell 에서 *다른 3D 위치*.
+ *
+ *   stock 식  (center origin, 균등 분할):
+ *     cx = (col - cols/2 + 0.5) * bayW         (bayW = rackWidth / cols)
+ *     cz = (row - rows/2 + 0.5) * bayD         (bayD = rackHeight / rows)
+ *
+ *   carrier 식 (top-left origin, widths/heights *비례* 분할):
+ *     innerX = (cumW + widths[col]/2) / wSum * rackWidth
+ *     innerY = (cumH + heights[row]/2) / hSum * rackDepthY
+ *
+ *   parent center-origin 변환 가정:
+ *     carrierCx = innerX - rackWidth/2
+ *     carrierCz = innerY - rackHeight/2
+ *
+ * 이 두 값이 같은 (col,row) 에서 *같은가* — 직접 비교.
+ */
+
+import 'should'
+
+// ── stock 위치 식 (rack-grid-3d.ts 의 matrixFor 발췌) ────────────────────────
+function stockPosition(col: number, row: number, opts: {
+  cols: number; rows: number; rackWidth: number; rackHeight: number
+}): { cx: number; cz: number } {
+  const { cols, rows, rackWidth, rackHeight } = opts
+  const bayW = rackWidth / cols
+  const bayD = rackHeight / rows
+  return {
+    cx: (col - cols / 2 + 0.5) * bayW,
+    cz: (row - rows / 2 + 0.5) * bayD
+  }
+}
+
+// ── carrier 위치 식 (rack-grid.ts 의 obtainCarrier 발췌) ────────────────────
+function carrierInner(col: number, row: number, opts: {
+  widths: number[]; heights: number[]; rackWidth: number; rackHeight: number
+}): { x: number; y: number } {
+  const { widths, heights, rackWidth, rackHeight } = opts
+  const wSum = widths.reduce((s, w) => s + w, 0)
+  const hSum = heights.reduce((s, h) => s + h, 0)
+  let cumW = 0
+  for (let c = 0; c < col; c++) cumW += widths[c]
+  let cumH = 0
+  for (let r = 0; r < row; r++) cumH += heights[r]
+  return {
+    x: (cumW + widths[col] / 2) / wSum * rackWidth,
+    y: (cumH + heights[row] / 2) / hSum * rackHeight
+  }
+}
+
+// parent 의 center-origin 변환 가정 — 자식 2D top-left origin → 3D center origin.
+function toCenterOrigin(inner: { x: number; y: number }, rackWidth: number, rackHeight: number) {
+  return {
+    cx: inner.x - rackWidth / 2,
+    cz: inner.y - rackHeight / 2
+  }
+}
+
+// ── 검증 ────────────────────────────────────────────────────────────────────
+
+describe('RackGrid picking 위치 — stock 식 vs carrier 식 직접 비교', () => {
+  it('uniform widths/heights — 두 식이 일치해야 한다', () => {
+    const cols = 5, rows = 3
+    const rackWidth = 400, rackHeight = 200
+    const widths = new Array(cols).fill(1)
+    const heights = new Array(rows).fill(1)
+
+    for (let col = 0; col < cols; col++) {
+      for (let row = 0; row < rows; row++) {
+        const stock = stockPosition(col, row, { cols, rows, rackWidth, rackHeight })
+        const inner = carrierInner(col, row, { widths, heights, rackWidth, rackHeight })
+        const carrier = toCenterOrigin(inner, rackWidth, rackHeight)
+
+        carrier.cx.should.be.approximately(stock.cx, 1e-9,
+          `mismatch at col=${col} row=${row}: carrier=${carrier.cx} stock=${stock.cx}`)
+        carrier.cz.should.be.approximately(stock.cz, 1e-9,
+          `mismatch at col=${col} row=${row}: carrier=${carrier.cz} stock=${stock.cz}`)
+      }
+    }
+  })
+
+  it('non-uniform widths — *bug 노출*: 두 식이 어긋남', () => {
+    // widths=[1,3] → 첫 cell 25%, 둘째 75% (carrier 식)
+    // stock 식은 widths 무시 — 균등 분할 (50% 50%)
+    const cols = 2, rows = 1
+    const rackWidth = 400, rackHeight = 100
+    const widths = [1, 3]
+    const heights = [1]
+
+    // col=0 비교
+    const stock0 = stockPosition(0, 0, { cols, rows, rackWidth, rackHeight })
+    const inner0 = carrierInner(0, 0, { widths, heights, rackWidth, rackHeight })
+    const carrier0 = toCenterOrigin(inner0, rackWidth, rackHeight)
+
+    // stock col=0 cx = (0 - 1 + 0.5) * 200 = -100 (균등 — bay 0 center)
+    stock0.cx.should.equal(-100)
+    // carrier inner col=0 x = (0 + 0.5)/4 * 400 = 50 → cx = 50 - 200 = -150
+    carrier0.cx.should.equal(-150)
+    // 둘이 다름 — bug 노출
+    carrier0.cx.should.not.equal(stock0.cx)
+  })
+
+  it('non-uniform heights — 마찬가지로 두 식이 어긋남', () => {
+    const cols = 1, rows = 2
+    const rackWidth = 100, rackHeight = 400
+    const widths = [1]
+    const heights = [1, 3]
+
+    const stock = stockPosition(0, 1, { cols, rows, rackWidth, rackHeight })
+    const inner = carrierInner(0, 1, { widths, heights, rackWidth, rackHeight })
+    const carrier = toCenterOrigin(inner, rackWidth, rackHeight)
+
+    // stock row=1 cz = (1 - 1 + 0.5) * 200 = 100 (균등 분할의 row=1 center)
+    stock.cz.should.equal(100)
+    // carrier row=1: cumH=1, (1 + 1.5)/4 * 400 = 250 → cz = 250 - 200 = 50
+    carrier.cz.should.equal(50)
+    carrier.cz.should.not.equal(stock.cz)
+  })
+
+  // ── *fix 후* 예상 동작 — carrier 식을 *stock 식과 동일하게 정렬* 한 경우 ─
+  it('fix 가정 — carrier 식이 stock 식과 동일하면 (균등 분할 + center origin) 일치', () => {
+    // 가정된 fix: carrier 도 균등 분할 + center origin 직접 사용
+    // (widths/heights 비례 무시. RackGrid 의 stock 자체가 균등 분할이므로 동일.)
+    function carrierFixed(col: number, row: number, opts: {
+      cols: number; rows: number; rackWidth: number; rackHeight: number
+    }): { cx: number; cz: number } {
+      const { cols, rows, rackWidth, rackHeight } = opts
+      const bayW = rackWidth / cols
+      const bayD = rackHeight / rows
+      return {
+        cx: (col - cols / 2 + 0.5) * bayW,
+        cz: (row - rows / 2 + 0.5) * bayD
+      }
+    }
+
+    const cols = 5, rows = 3
+    const rackWidth = 400, rackHeight = 200
+    for (let col = 0; col < cols; col++) {
+      for (let row = 0; row < rows; row++) {
+        const stock = stockPosition(col, row, { cols, rows, rackWidth, rackHeight })
+        const carrier = carrierFixed(col, row, { cols, rows, rackWidth, rackHeight })
+        carrier.cx.should.equal(stock.cx)
+        carrier.cz.should.equal(stock.cz)
+      }
+    }
+  })
+})

package/test/test-rack-grid-slot-api.ts

@@ -0,0 +1,483 @@
+/*
+ * RackGrid — Plan A Slot API unit tests.
+ *
+ * storage-rack 의 test-storage-rack-slot-api.ts 패턴 그대로. things-scene 의
+ * full pipeline 우회하고 *순수 슬롯 의미론 + RackGrid 고유 (cellOverrides
+ * isEmpty / widths-heights 비례 좌표 계산)* 만 격리 검증.
+ *
+ * 검증 대상:
+ *  - obtainCarrier: RackGrid 자체 records 에서 transient materialize (자식 위임 X)
+ *  - receiveAt: carrier dispose + records push
+ *  - canReceiveAt: isEmpty cell 거부 + 점유 거부
+ *  - hasCarrierAt: record + carrier-child 양쪽 인식
+ *  - recordFromCarrier: SKIP_KEYS 제외
+ *  - 좌표 계산: widths/heights 비례 분할의 정확성 (picking 위치 일치)
+ */
+
+import 'should'
+
+// ── Fixture: RackGrid 의 핵심 의미론을 격리한 mini-grid ────────────────────────
+
+class MiniRackGrid {
+  state: any
+  components: any[] = []
+  _disposed = new Set<any>()
+
+  constructor(opts: {
+    columns?: number
+    rows?: number
+    shelves?: number
+    width?: number       // 3D X (RackGrid 의 state.width)
+    height?: number      // 3D Z = 2D height (state.height)
+    widths?: number[]
+    heights?: number[]
+    cellOverrides?: { [posKey: string]: { isEmpty?: boolean } }
+    initialData?: any[]
+  } = {}) {
+    this.state = {
+      columns: opts.columns ?? 5,
+      rows: opts.rows ?? 3,
+      shelves: opts.shelves ?? 4,
+      width: opts.width ?? 400,
+      height: opts.height ?? 200,
+      widths: opts.widths,
+      heights: opts.heights,
+      cellOverrides: opts.cellOverrides ?? {},
+      data: opts.initialData ?? []
+    }
+  }
+
+  // ── accessors (NaN-safe) ─────────────────────────────────
+  get columns(): number {
+    const v = this.state.columns
+    return Math.max(1, Math.floor(typeof v === 'number' && Number.isFinite(v) ? v : 5))
+  }
+  get rackRows(): number {
+    const v = this.state.rows
+    return Math.max(1, Math.floor(typeof v === 'number' && Number.isFinite(v) ? v : 1))
+  }
+  get shelves(): number {
+    const v = this.state.shelves
+    return Math.max(1, Math.floor(typeof v === 'number' && Number.isFinite(v) ? v : 4))
+  }
+
+  get widths(): number[] {
+    const w = this.state.widths as number[] | undefined
+    if (!w) return new Array(this.columns).fill(1)
+    if (w.length < this.columns) return w.concat(new Array(this.columns - w.length).fill(1))
+    if (w.length > this.columns) return w.slice(0, this.columns)
+    return w
+  }
+  get heights(): number[] {
+    const h = this.state.heights as number[] | undefined
+    if (!h) return new Array(this.rackRows).fill(1)
+    if (h.length < this.rackRows) return h.concat(new Array(this.rackRows - h.length).fill(1))
+    if (h.length > this.rackRows) return h.slice(0, this.rackRows)
+    return h
+  }
+  get widths_sum(): number {
+    return this.widths.reduce((s, w) => s + w, 0) || this.columns
+  }
+  get heights_sum(): number {
+    return this.heights.reduce((s, h) => s + h, 0) || this.rackRows
+  }
+
+  get records(): any[] {
+    return this.state.data ?? []
+  }
+  get cellOverrides(): { [k: string]: { isEmpty?: boolean } } {
+    return this.state.cellOverrides ?? {}
+  }
+
+  // ── helpers ─────────────────────────────────────────────
+  parseSlotId(cellId: string): { col: number; row: number; shelf: number } | null {
+    const parts = cellId.split('-')
+    if (parts.length !== 3) return null
+    const [c, r, s] = parts.map(Number)
+    if (!Number.isFinite(c) || !Number.isFinite(r) || !Number.isFinite(s)) return null
+    return { col: c, row: r, shelf: s }
+  }
+
+  /** RackGrid-inner 의 cell center 좌표 (widths/heights 비례 분할). */
+  cellCenterInner(cellId: string): { x: number; y: number } | null {
+    const parsed = this.parseSlotId(cellId)
+    if (!parsed) return null
+    const widthsArr = this.widths
+    const heightsArr = this.heights
+    const wSum = this.widths_sum
+    const hSum = this.heights_sum
+    const rackWidth = this.state.width ?? 400
+    const rackDepthY = this.state.height ?? 200
+    let cumW = 0
+    for (let c = 0; c < parsed.col; c++) cumW += widthsArr[c]
+    let cumH = 0
+    for (let r = 0; r < parsed.row; r++) cumH += heightsArr[r]
+    return {
+      x: (cumW + widthsArr[parsed.col] / 2) / wSum * rackWidth,
+      y: (cumH + heightsArr[parsed.row] / 2) / hSum * rackDepthY
+    }
+  }
+
+  // ── operations ──────────────────────────────────────────
+  setState(key: string, value: any): void {
+    this.state[key] = value
+  }
+
+  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
+  }
+
+  _carrierChildAt(cellId: string): any {
+    return this.components.find(c => c.state?.cellId === cellId && c.placement === 'operation')
+  }
+
+  hasCarrierAt(cellId: string): boolean {
+    if (this._carrierChildAt(cellId)) return true
+    return this.records.some(r => r?.cellId === cellId)
+  }
+
+  obtainCarrier(cellId: string): any {
+    const existing = this._carrierChildAt(cellId)
+    if (existing) return existing
+
+    const idx = this.records.findIndex(r => r?.cellId === cellId)
+    if (idx === -1) return null
+    const record = this.records[idx]
+
+    const center = this.cellCenterInner(cellId)
+    if (!center) return null
+
+    const carrier: any = {
+      placement: 'operation',
+      state: {
+        ...record,
+        type: record.type ?? 'parcel',
+        cellId,
+        // RackGrid-inner 좌표 — center 기준 carrier top-left.
+        left: center.x - 10,
+        top: center.y - 10,
+        width: 20,
+        height: 20
+      },
+      parent: null,
+      dispose() { /* test */ }
+    }
+    this.addComponent(carrier)
+    this.setState('data', this.records.filter((_, i) => i !== idx))
+    return carrier
+  }
+
+  canReceiveAt(cellId: string, carrier?: any): boolean {
+    const parsed = this.parseSlotId(cellId)
+    if (!parsed) return false
+    const override = this.cellOverrides[`${parsed.col}-${parsed.row}`]
+    if (override?.isEmpty) return false
+
+    if (this.records.some(r => r?.cellId === cellId)) return false
+    const existing = this._carrierChildAt(cellId)
+    if (existing && existing !== carrier) return false
+    return true
+  }
+
+  async receiveAt(cellId: string, carrier: any): Promise<void> {
+    if (!this.canReceiveAt(cellId, carrier)) return
+
+    const record = this.recordFromCarrier(carrier, cellId)
+    const p = carrier.parent
+    if (p && typeof p.removeComponent === 'function') p.removeComponent(carrier)
+    this._disposed.add(carrier)
+    carrier.dispose?.()
+
+    this.setState('data', [...this.records, record])
+  }
+
+  recordFromCarrier(carrier: any, cellId: string): any {
+    const state = carrier.state ?? {}
+    const SKIP = new Set([
+      'left', 'top', 'zPos',
+      'transform', 'rotation', 'scale',
+      '_transferSlotId',
+      'cellId', 'id', 'refid'
+    ])
+    const record: any = { cellId, type: state.type }
+    for (const k of Object.keys(state)) {
+      if (SKIP.has(k)) continue
+      record[k] = state[k]
+    }
+    return record
+  }
+}
+
+// ── Group 1: obtainCarrier ──────────────────────────────────────────────────
+
+describe('RackGrid Plan A: obtainCarrier — RackGrid 자체 records 에서 materialize', () => {
+  it('record 가 있는 cellId → carrier materialize, record 제거', () => {
+    const grid = new MiniRackGrid({
+      initialData: [
+        { cellId: '0-0-0', sku: 'A', qty: 1 },
+        { cellId: '1-1-2', sku: 'B', qty: 2 }
+      ]
+    })
+
+    const carrier = grid.obtainCarrier('0-0-0')!
+    carrier.should.not.be.null()
+    carrier.state.sku.should.equal('A')
+    carrier.state.cellId.should.equal('0-0-0')
+    carrier.parent.should.equal(grid)
+
+    grid.records.length.should.equal(1)
+    grid.records[0].cellId.should.equal('1-1-2')
+    grid.components.length.should.equal(1)
+  })
+
+  it('record 가 없는 cellId → null (실제 버그 재현 — 사용자 보고 동일)', () => {
+    const grid = new MiniRackGrid({
+      initialData: [{ cellId: '0-0-0', sku: 'X' }]
+    })
+    // 사용자가 '1-11-2' 호출 → record 가 '0-0-0' 이라 null. 호출 cellId 자체 불일치.
+    ;(grid.obtainCarrier('1-11-2') === null).should.be.true()
+    grid.records.length.should.equal(1)
+  })
+
+  it('이미 child carrier 가 있는 cellId → 그 child 그대로 반환 (idempotent)', () => {
+    const grid = new MiniRackGrid()
+    const existing: any = {
+      placement: 'operation',
+      state: { cellId: '2-1-0', sku: 'X' },
+      parent: grid
+    }
+    grid.components.push(existing)
+
+    const got = grid.obtainCarrier('2-1-0')
+    got!.should.equal(existing)
+    grid.records.length.should.equal(0)
+    grid.components.length.should.equal(1)
+  })
+
+  it('obtainCarrier 2회 연속 → 두 번째는 같은 carrier', () => {
+    const grid = new MiniRackGrid({ initialData: [{ cellId: '0-0-0', sku: 'A' }] })
+    const c1 = grid.obtainCarrier('0-0-0')
+    const c2 = grid.obtainCarrier('0-0-0')
+    c1!.should.equal(c2)
+    grid.records.length.should.equal(0)
+  })
+
+  it('잘못된 cellId 형식 → null', () => {
+    const grid = new MiniRackGrid({ initialData: [{ cellId: '0-0-0' }] })
+    ;(grid.obtainCarrier('0-0') === null).should.be.true()    // 2 segments
+    ;(grid.obtainCarrier('a-b-c') === null).should.be.true()  // non-numeric
+  })
+})
+
+// ── Group 2: receiveAt ──────────────────────────────────────────────────────
+
+describe('RackGrid Plan A: receiveAt — absorb carrier into records', () => {
+  it('carrier 받으면 dispose + records 에 push', async () => {
+    const grid = new MiniRackGrid()
+    const carrier: any = {
+      placement: 'operation',
+      state: { type: 'parcel', sku: 'X', qty: 5 },
+      parent: { removeComponent: () => {} },
+      dispose() {}
+    }
+
+    await grid.receiveAt('2-0-3', carrier)
+
+    grid._disposed.has(carrier).should.be.true()
+    grid.records.length.should.equal(1)
+    grid.records[0].cellId.should.equal('2-0-3')
+    grid.records[0].sku.should.equal('X')
+    grid.records[0].type.should.equal('parcel')
+  })
+
+  it('이미 점유된 cellId → reject', async () => {
+    const grid = new MiniRackGrid({
+      initialData: [{ cellId: '0-0-0', sku: 'occupied' }]
+    })
+    const carrier: any = {
+      placement: 'operation',
+      state: { type: 'parcel', sku: 'X' },
+      parent: { removeComponent: () => {} },
+      dispose() {}
+    }
+
+    await grid.receiveAt('0-0-0', carrier)
+
+    grid._disposed.has(carrier).should.be.false()
+    grid.records.length.should.equal(1)
+    grid.records[0].sku.should.equal('occupied')
+  })
+})
+
+// ── Group 3: canReceiveAt — isEmpty cell 거부 ───────────────────────────────
+
+describe('RackGrid Plan A: canReceiveAt — isEmpty / 점유 검사', () => {
+  it('cellOverrides.isEmpty=true 위치는 거부', () => {
+    const grid = new MiniRackGrid({
+      cellOverrides: { '1-1': { isEmpty: true } }
+    })
+    grid.canReceiveAt('1-1-0').should.be.false()
+    grid.canReceiveAt('1-1-2').should.be.false()
+    // 다른 col-row 는 가능
+    grid.canReceiveAt('0-0-0').should.be.true()
+  })
+
+  it('records 점유 시 거부', () => {
+    const grid = new MiniRackGrid({
+      initialData: [{ cellId: '0-0-0' }]
+    })
+    grid.canReceiveAt('0-0-0').should.be.false()
+    grid.canReceiveAt('0-0-1').should.be.true()
+  })
+
+  it('자기 자신 carrier 가 child 면 idempotent true (자기 자리 복귀)', () => {
+    const grid = new MiniRackGrid()
+    const carrier: any = {
+      placement: 'operation', state: { cellId: '0-0-0' }, parent: grid
+    }
+    grid.components.push(carrier)
+    grid.canReceiveAt('0-0-0', carrier).should.be.true()
+    // 다른 carrier 면 false
+    grid.canReceiveAt('0-0-0', {} as any).should.be.false()
+  })
+
+  it('잘못된 cellId 형식 → false', () => {
+    const grid = new MiniRackGrid()
+    grid.canReceiveAt('xyz').should.be.false()
+    grid.canReceiveAt('0-0').should.be.false()
+  })
+})
+
+// ── Group 4: hasCarrierAt ───────────────────────────────────────────────────
+
+describe('RackGrid Plan A: hasCarrierAt — record + child 양쪽 인식', () => {
+  it('record 만 → true', () => {
+    const grid = new MiniRackGrid({ initialData: [{ cellId: '0-0-0' }] })
+    grid.hasCarrierAt('0-0-0').should.be.true()
+    grid.hasCarrierAt('1-1-1').should.be.false()
+  })
+
+  it('child carrier 만 → true', () => {
+    const grid = new MiniRackGrid()
+    grid.components.push({ placement: 'operation', state: { cellId: '1-2-3' } } as any)
+    grid.hasCarrierAt('1-2-3').should.be.true()
+  })
+
+  it('record / child 둘 다 없음 → false', () => {
+    const grid = new MiniRackGrid()
+    grid.hasCarrierAt('0-0-0').should.be.false()
+  })
+})
+
+// ── Group 5: 좌표 계산 — widths/heights 비례 분할 ───────────────────────────
+
+describe('RackGrid: cellCenterInner — picking 위치 좌표 정확성', () => {
+  it('uniform widths/heights → 균등 분할', () => {
+    // cols=2, rows=2, rackWidth=100, rackHeight=80, widths=[1,1], heights=[1,1]
+    const grid = new MiniRackGrid({
+      columns: 2, rows: 2, width: 100, height: 80
+    })
+    grid.cellCenterInner('0-0-0')!.should.deepEqual({ x: 25, y: 20 })
+    grid.cellCenterInner('1-0-0')!.should.deepEqual({ x: 75, y: 20 })
+    grid.cellCenterInner('0-1-0')!.should.deepEqual({ x: 25, y: 60 })
+    grid.cellCenterInner('1-1-0')!.should.deepEqual({ x: 75, y: 60 })
+  })
+
+  it('non-uniform widths → 비례 분할', () => {
+    // widths=[1,3], 첫 cell 25%, 둘째 75%. rackWidth=400.
+    const grid = new MiniRackGrid({
+      columns: 2, rows: 1, width: 400, height: 100,
+      widths: [1, 3]
+    })
+    // wSum=4, col=0: (0 + 0.5)/4 * 400 = 50
+    grid.cellCenterInner('0-0-0')!.x.should.equal(50)
+    // col=1: (1 + 1.5)/4 * 400 = 250
+    grid.cellCenterInner('1-0-0')!.x.should.equal(250)
+  })
+
+  it('shelf 인덱스는 inner 2D 좌표에 영향 X (3D Y 축 별도)', () => {
+    const grid = new MiniRackGrid({
+      columns: 3, rows: 3, shelves: 5, width: 300, height: 300
+    })
+    const c0 = grid.cellCenterInner('1-1-0')!
+    const c4 = grid.cellCenterInner('1-1-4')!
+    c0.should.deepEqual(c4)
+  })
+
+  it('잘못된 cellId 형식 → null', () => {
+    const grid = new MiniRackGrid()
+    ;(grid.cellCenterInner('xyz') === null).should.be.true()
+    ;(grid.cellCenterInner('0-0') === null).should.be.true()
+  })
+})
+
+// ── Group 6: 불변식 — record ↔ child 상호 배타 ─────────────────────────────
+
+describe('RackGrid Plan A: 불변식 — record ↔ child 양쪽 동시 X', () => {
+  it('obtainCarrier 가 record 제거 → child 와 record 동일 cellId 양립 안 함', () => {
+    const grid = new MiniRackGrid({ initialData: [{ cellId: 'A-B-C' }] })
+    // cellId 가 숫자가 아니라 parseSlotId 가 null — obtain 도 null. 적절한 cellId 로 재시도.
+    const grid2 = new MiniRackGrid({ initialData: [{ cellId: '0-0-0' }] })
+    const c = grid2.obtainCarrier('0-0-0')!
+    grid2._carrierChildAt('0-0-0').should.equal(c)
+    grid2.records.some((r: any) => r.cellId === '0-0-0').should.be.false()
+  })
+
+  it('Full cycle — record → carrier → 다른 cell 로 receive', async () => {
+    const grid = new MiniRackGrid({ initialData: [{ cellId: '0-0-0', sku: 'X' }] })
+
+    // 1. record 만 존재
+    grid.hasCarrierAt('0-0-0').should.be.true()
+    grid.hasCarrierAt('1-1-1').should.be.false()
+
+    // 2. obtain → child 로
+    const carrier = grid.obtainCarrier('0-0-0')!
+    grid.hasCarrierAt('0-0-0').should.be.true()
+    grid.records.some((r: any) => r.cellId === '0-0-0').should.be.false()
+
+    // 3. 외부로 picked
+    grid.removeComponent(carrier)
+    carrier.parent = { removeComponent: () => {} }
+    grid.hasCarrierAt('0-0-0').should.be.false()
+
+    // 4. 새 cellId 로 receiveAt
+    await grid.receiveAt('1-1-1', carrier)
+    grid.hasCarrierAt('0-0-0').should.be.false()
+    grid.hasCarrierAt('1-1-1').should.be.true()
+    grid._disposed.has(carrier).should.be.true()
+  })
+})
+
+// ── Group 7: recordFromCarrier ──────────────────────────────────────────────
+
+describe('RackGrid Plan A: recordFromCarrier — transform 제외, 의미 보존', () => {
+  it('transform / id / refid 류는 record 에서 제외', () => {
+    const grid = new MiniRackGrid()
+    const carrier: any = {
+      state: {
+        type: 'parcel', sku: 'A', qty: 3,
+        left: 100, top: 200, zPos: 50,
+        transform: 'rotate(45deg)', rotation: 90, scale: 2,
+        _transferSlotId: 'forks',
+        cellId: 'old-cell', id: 'comp-id', refid: 999
+      }
+    }
+    const r = grid.recordFromCarrier(carrier, 'new-cell')
+    r.cellId.should.equal('new-cell')
+    r.type.should.equal('parcel')
+    r.sku.should.equal('A')
+    r.qty.should.equal(3)
+    ;('left' in r).should.be.false()
+    ;('transform' in r).should.be.false()
+    ;('id' in r).should.be.false()
+    ;('refid' in r).should.be.false()
+    ;('_transferSlotId' in r).should.be.false()
+  })
+})